From a47b6d074de271f1f94024b49c80575f95d721ad Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Sun, 19 Dec 2021 13:25:09 -0800
Subject: [PATCH 01/37] P1206R7 Conversions From Ranges To Containers

`<ranges>`: Implement `ranges::to`, guarded by `__cpp_lib_ranges_to_container`.

The following are all guarded  by `__cpp_lib_containers_ranges`:
`<xmemory>`: Generalize `_Uninitialized_copy` to iterator+sentinel ranges; add `_Uninitialized_copy_n` for counted ranges. Implement `from_range_t`, `from_range`, and exposition-only helper concepts / type aliases.
`<xutility>`: Promote `_Get_final_iterator_unwrapped` here from `<algorithm>`. Add `_Copy_memmove_n` (`_Copy_n_unchecked`), similar to `_Copy_memmove` (resp. `_Copy_unchecked`) but for counted ranges. Generalize `_Iter_copy_cat` to `_Sent_copy_cat`.
`<memory>`: Use `_Copy_memmove_n` (see `<xutility>`) as appropriate.

`<yvals_core.h>`: `_HAS_CXX23` controls P1206R7, define `__cpp_lib_containers_ranges` and `__cpp_lib_ranges_to_container`.

`<deque>`: Implement `from_range_t` constructor(s) and corresponding deduction guide(s), `prepend_range`, `append_range`, `assign_range`, and `insert_range`.
`<forward_list>`: Implement `from_range_t` constructor(s) and corresponding deduction guide(s), `prepend_range`, `assign_range`, and `insert_range_after`.
`<list>`: Implement `from_range_t` constructor(s) and corresponding deduction guide(s), `prepend_range`, `append_range`, `assign_range`, and `insert_range`.
`<map>` and `<set>`: For both `map`, `multimap`, `set`, and `multiset`, implement `from_range_t` constructor(s) and corresponding deduction guide(s). (Inherit `insert_range` from `_Tree`.)
`<queue>`: For both `queue` and `priority_queue`, implement `from_range_t` constructor(s) and corresponding deduction guide(s), and `push_range`. (I've speculatively implemented `priority_queue::push_range` by calling `append_range` on the container per the resolution I've proposed for an LWG issue I submitted specifically to allow implementation via `append_range`.)
`<stack>`: Implement `from_range_t` constructor(s) and corresponding deduction guide(s), and `push_range`.
`<unordered_map>` and `<unordered_set>`: For both `unordered_map`, `unordered_multimap`, `unordered_set`, and `unordered_multiset`, implement `from_range_t` constructor(s) and corresponding deduction guide(s). (Inherit `insert_range` from `_Hash`.)
`<vector>`: For both `vector` and `vector<bool>`, implement `from_range_t` constructor(s) and corresponding deduction guide(s), `append_range`, `assign_range`, and `insert_range`.
`<xstring>`: For both `basic_string`, implement `from_range_t` constructor(s) and corresponding deduction guide(s), `append_range`, `assign_range`, `insert_range`, and `replace_with_range`.

Test both new feature-test macros in `tests/std/tests/VSO_0157762_feature_test_macros`.
Test all new deduction guides in `tests/std/tests/P0433R2_deduction_guides`.
Test `_Copy_n_unchecked` in `tests/std/tests/P0784R7_library_machinery`.
Add new t`P1206R7_{container}_{operation}` "range algorithm"-style tests for each new container (or container adapter) member function.
Add new `P1206R7_from_range` test for `from_range` and `from_range_t`.
Add new `P1206R7_ranges_to` test for `ranges::to`.

Fixes #2532.
---
 stl/inc/algorithm                             |  56 +-
 stl/inc/deque                                 | 250 +++++--
 stl/inc/forward_list                          |  70 +-
 stl/inc/list                                  |  96 ++-
 stl/inc/map                                   |  68 ++
 stl/inc/memory                                |   8 +-
 stl/inc/queue                                 |  86 +++
 stl/inc/ranges                                | 127 ++++
 stl/inc/set                                   |  65 ++
 stl/inc/stack                                 |  34 +
 stl/inc/unordered_map                         | 153 +++++
 stl/inc/unordered_set                         | 152 +++++
 stl/inc/vector                                | 446 ++++++++++---
 stl/inc/xhash                                 |  26 +-
 stl/inc/xmemory                               |  84 ++-
 stl/inc/xstring                               | 160 ++++-
 stl/inc/xtree                                 |  26 +-
 stl/inc/xutility                              | 132 +++-
 stl/inc/yvals_core.h                          |   5 +-
 tests/std/test.lst                            |  47 ++
 .../tests/P0433R2_deduction_guides/test.cpp   | 145 ++++-
 .../tests/P0784R7_library_machinery/test.cpp  |  10 +
 .../tests/P1206R7_deque_append_range/env.lst  |   4 +
 .../tests/P1206R7_deque_append_range/test.cpp |  87 +++
 .../tests/P1206R7_deque_assign_range/env.lst  |   4 +
 .../tests/P1206R7_deque_assign_range/test.cpp |  81 +++
 .../tests/P1206R7_deque_from_range/env.lst    |   4 +
 .../tests/P1206R7_deque_from_range/test.cpp   |  69 ++
 .../tests/P1206R7_deque_insert_range/env.lst  |   4 +
 .../tests/P1206R7_deque_insert_range/test.cpp |  86 +++
 .../tests/P1206R7_deque_prepend_range/env.lst |   4 +
 .../P1206R7_deque_prepend_range/test.cpp      |  85 +++
 .../P1206R7_forward_list_assign_range/env.lst |   4 +
 .../test.cpp                                  |  80 +++
 .../P1206R7_forward_list_from_range/env.lst   |   4 +
 .../P1206R7_forward_list_from_range/test.cpp  |  69 ++
 .../P1206R7_forward_list_insert_range/env.lst |   4 +
 .../test.cpp                                  |  86 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  84 +++
 tests/std/tests/P1206R7_from_range/env.lst    |   4 +
 .../P1206R7_from_range/test.compile.pass.cpp  |  21 +
 .../tests/P1206R7_list_append_range/env.lst   |   4 +
 .../tests/P1206R7_list_append_range/test.cpp  |  87 +++
 .../tests/P1206R7_list_assign_range/env.lst   |   4 +
 .../tests/P1206R7_list_assign_range/test.cpp  |  81 +++
 .../std/tests/P1206R7_list_from_range/env.lst |   4 +
 .../tests/P1206R7_list_from_range/test.cpp    |  69 ++
 .../tests/P1206R7_list_insert_range/env.lst   |   4 +
 .../tests/P1206R7_list_insert_range/test.cpp  |  87 +++
 .../tests/P1206R7_list_prepend_range/env.lst  |   4 +
 .../tests/P1206R7_list_prepend_range/test.cpp |  85 +++
 .../std/tests/P1206R7_map_from_range/env.lst  |   4 +
 .../std/tests/P1206R7_map_from_range/test.cpp |  82 +++
 .../tests/P1206R7_map_insert_range/env.lst    |   4 +
 .../tests/P1206R7_map_insert_range/test.cpp   |  83 +++
 .../tests/P1206R7_multimap_from_range/env.lst |   4 +
 .../P1206R7_multimap_from_range/test.cpp      |  84 +++
 .../P1206R7_multimap_insert_range/env.lst     |   4 +
 .../P1206R7_multimap_insert_range/test.cpp    |  83 +++
 .../tests/P1206R7_multiset_from_range/env.lst |   4 +
 .../P1206R7_multiset_from_range/test.cpp      |  82 +++
 .../P1206R7_multiset_insert_range/env.lst     |   4 +
 .../P1206R7_multiset_insert_range/test.cpp    |  83 +++
 .../P1206R7_priority_queue_from_range/env.lst |   4 +
 .../test.cpp                                  |  85 +++
 .../P1206R7_priority_queue_push_range/env.lst |   4 +
 .../test.cpp                                  | 102 +++
 .../tests/P1206R7_queue_from_range/env.lst    |   4 +
 .../tests/P1206R7_queue_from_range/test.cpp   |  83 +++
 .../tests/P1206R7_queue_push_range/env.lst    |   4 +
 .../tests/P1206R7_queue_push_range/test.cpp   | 101 +++
 tests/std/tests/P1206R7_ranges_to/env.lst     |   4 +
 tests/std/tests/P1206R7_ranges_to/test.cpp    | 616 ++++++++++++++++++
 .../std/tests/P1206R7_set_from_range/env.lst  |   4 +
 .../std/tests/P1206R7_set_from_range/test.cpp |  81 +++
 .../tests/P1206R7_set_insert_range/env.lst    |   4 +
 .../tests/P1206R7_set_insert_range/test.cpp   |  82 +++
 .../tests/P1206R7_stack_from_range/env.lst    |   4 +
 .../tests/P1206R7_stack_from_range/test.cpp   |  83 +++
 .../tests/P1206R7_stack_push_range/env.lst    |   4 +
 .../tests/P1206R7_stack_push_range/test.cpp   | 101 +++
 .../tests/P1206R7_string_append_range/env.lst |   4 +
 .../P1206R7_string_append_range/test.cpp      | 128 ++++
 .../tests/P1206R7_string_assign_range/env.lst |   4 +
 .../P1206R7_string_assign_range/test.cpp      | 125 ++++
 .../tests/P1206R7_string_from_range/env.lst   |   4 +
 .../tests/P1206R7_string_from_range/test.cpp  | 148 +++++
 .../tests/P1206R7_string_insert_range/env.lst |   4 +
 .../P1206R7_string_insert_range/test.cpp      | 130 ++++
 .../P1206R7_string_replace_with_range/env.lst |   4 +
 .../test.cpp                                  | 144 ++++
 .../P1206R7_unordered_map_from_range/env.lst  |   4 +
 .../P1206R7_unordered_map_from_range/test.cpp |  83 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  84 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  85 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  86 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  83 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  84 +++
 .../P1206R7_unordered_set_from_range/env.lst  |   4 +
 .../P1206R7_unordered_set_from_range/test.cpp |  83 +++
 .../env.lst                                   |   4 +
 .../test.cpp                                  |  84 +++
 .../tests/P1206R7_vector_append_range/env.lst |   4 +
 .../P1206R7_vector_append_range/test.cpp      | 162 +++++
 .../tests/P1206R7_vector_assign_range/env.lst |   4 +
 .../P1206R7_vector_assign_range/test.cpp      | 168 +++++
 .../tests/P1206R7_vector_from_range/env.lst   |   4 +
 .../tests/P1206R7_vector_from_range/test.cpp  | 146 +++++
 .../tests/P1206R7_vector_insert_range/env.lst |   4 +
 .../P1206R7_vector_insert_range/test.cpp      | 166 +++++
 .../test.compile.pass.cpp                     |  28 +
 117 files changed, 7203 insertions(+), 236 deletions(-)
 create mode 100644 tests/std/tests/P1206R7_deque_append_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_deque_append_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_deque_assign_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_deque_assign_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_deque_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_deque_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_deque_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_deque_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_deque_prepend_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_deque_prepend_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_forward_list_assign_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_forward_list_assign_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_forward_list_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_forward_list_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_forward_list_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_forward_list_prepend_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_from_range/test.compile.pass.cpp
 create mode 100644 tests/std/tests/P1206R7_list_append_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_list_append_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_list_assign_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_list_assign_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_list_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_list_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_list_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_list_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_list_prepend_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_list_prepend_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_map_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_map_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_map_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_map_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_multimap_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_multimap_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_multimap_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_multimap_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_multiset_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_multiset_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_multiset_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_multiset_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_priority_queue_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_priority_queue_push_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_queue_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_queue_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_queue_push_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_queue_push_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_ranges_to/env.lst
 create mode 100644 tests/std/tests/P1206R7_ranges_to/test.cpp
 create mode 100644 tests/std/tests/P1206R7_set_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_set_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_set_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_set_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_stack_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_stack_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_stack_push_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_stack_push_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_string_append_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_string_append_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_string_assign_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_string_assign_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_string_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_string_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_string_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_string_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_string_replace_with_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_string_replace_with_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_map_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_map_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_multimap_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_multimap_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_multiset_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_multiset_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_multiset_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_multiset_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_set_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_unordered_set_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_vector_append_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_vector_append_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_vector_assign_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_vector_assign_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_vector_from_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_vector_from_range/test.cpp
 create mode 100644 tests/std/tests/P1206R7_vector_insert_range/env.lst
 create mode 100644 tests/std/tests/P1206R7_vector_insert_range/test.cpp

diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 1c087211a7..41b1ffea98 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -254,56 +254,6 @@ namespace ranges {
             return {_STD move(in), found};
         }
     };
-
-    // clang-format off
-    template <forward_iterator _Wrapped, class _Se>
-        requires sentinel_for<remove_cvref_t<_Se>, _Wrapped>
-    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(const _Unwrapped_t<_Wrapped>& _UFirst, _Se&& _Last) {
-        // clang-format on
-        // find the iterator in [_UFirst, _Get_unwrapped(_Last)) which equals _Get_unwrapped(_Last) [possibly O(N)]
-        auto _ULast = _Get_unwrapped(_STD forward<_Se>(_Last));
-        if constexpr (is_same_v<remove_cvref_t<_Se>, _Wrapped>) {
-            return _ULast;
-        } else if constexpr (sized_sentinel_for<remove_cvref_t<_Se>, _Wrapped>) {
-            return _RANGES next(_UFirst, _ULast - _UFirst);
-        } else {
-            return _RANGES next(_UFirst, _STD move(_ULast));
-        }
-    }
-
-    template <forward_range _Rng>
-    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
-        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
-        if constexpr (common_range<_Rng>) {
-            if constexpr (same_as<_Unwrapped_t<_RANGES iterator_t<_Rng>>, decltype(_Uend(_Range))>) {
-                return _Uend(_Range);
-            } else {
-                return _Get_unwrapped(_RANGES end(_Range));
-            }
-        } else if constexpr (sized_range<_Rng>) {
-            return _RANGES next(_Ubegin(_Range), _RANGES distance(_Range));
-        } else {
-            return _RANGES next(_Ubegin(_Range), _Uend(_Range));
-        }
-    }
-
-    template <forward_range _Rng>
-    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range, const _Unwrapped_t<iterator_t<_Rng>>& _Mid) {
-        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
-        // Pre: [ranges::begin(_Range), _Mid) and [_Mid, ranges::end(_Range)) denote ranges
-        if constexpr (common_range<_Rng>) {
-            return _Uend(_Range);
-        } else if constexpr (sized_range<_Rng>) {
-            const auto _Dist = _RANGES distance(_Range);
-            if constexpr (sized_sentinel_for<_Unwrapped_t<iterator_t<_Rng>>, _Unwrapped_t<iterator_t<_Rng>>>) {
-                return _RANGES next(_Mid, _Dist - (_Mid - _Ubegin(_Range)));
-            } else {
-                return _RANGES next(_Ubegin(_Range), _Dist);
-            }
-        } else {
-            return _RANGES next(_Mid, _Uend(_Range));
-        }
-    }
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -1377,9 +1327,9 @@ namespace ranges {
             auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count);
             if constexpr (_Iter_copy_cat<decltype(_UFirst), _Out>::_Bitcopy_assignable) {
                 if (!_STD is_constant_evaluated()) {
-                    auto _Final = _UFirst + _Count;
-                    _Result     = _Copy_memmove(_STD move(_UFirst), _Final, _STD move(_Result));
-                    _Seek_wrapped(_First, _STD move(_Final));
+                    _Result = _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _STD move(_Result));
+                    _UFirst += _Count;
+                    _Seek_wrapped(_First, _STD move(_UFirst));
                     return {_STD move(_First), _STD move(_Result)};
                 }
             }
diff --git a/stl/inc/deque b/stl/inc/deque
index d045c20b5b..c2888863e8 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -673,12 +673,30 @@ public:
         _Proxy._Release();
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    deque(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Alproxy_ty _Alproxy(_Getal());
+        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
+        _Construct(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Proxy._Release();
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    deque(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Alproxy_ty _Alproxy(_Getal());
+        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
+        _Construct(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Proxy._Release();
+    }
+#endif // __cpp_lib_containers_ranges
+
 private:
-    template <class _Iter>
-    void _Construct(_Iter _First, _Iter _Last) { // initialize from [_First, _Last), input iterators
+    template <class _Iter, class _Sent>
+    void _Construct(_Iter _First, const _Sent _Last) { // initialize from input range [_First, _Last)
         _Tidy_guard<deque> _Guard{this};
         for (; _First != _Last; ++_First) {
-            emplace_back(*_First);
+            _Emplace_back_internal(*_First);
         }
 
         _Guard._Target = nullptr;
@@ -772,11 +790,66 @@ public:
         emplace_front(_STD move(_Val));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        _Orphan_all();
+
+        const auto _Oldsize = _Mysize();
+        _TRY_BEGIN
+        if constexpr (_RANGES bidirectional_range<_Rng>) {
+            auto _ULast        = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const auto _UFirst = _RANGES _Ubegin(_Range);
+            while (_UFirst != _ULast) {
+                _Emplace_front_internal(*--_ULast);
+            }
+        } else {
+            auto _UFirst      = _RANGES _Ubegin(_Range);
+            const auto _ULast = _RANGES _Uend(_Range);
+            for (; _UFirst != _ULast; ++_UFirst) {
+                _Emplace_front_internal(*_UFirst); // prepend flipped
+            }
+        }
+        _CATCH_ALL
+        while (_Oldsize < _Mysize()) {
+            pop_front(); // restore old size, at least
+        }
+        _RERAISE;
+        _CATCH_END
+
+        if constexpr (!_RANGES bidirectional_range<_Rng>) {
+            const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
+            _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     void push_back(_Ty&& _Val) {
         _Orphan_all();
         _Emplace_back_internal(_STD move(_Val));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void append_range(_Rng&& _Range) {
+        _Orphan_all();
+
+        const auto _Oldsize = _Mysize();
+        auto _UFirst        = _RANGES _Ubegin(_Range);
+        const auto _ULast   = _RANGES _Uend(_Range);
+        _TRY_BEGIN
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _Emplace_back_internal(*_UFirst);
+        }
+        _CATCH_ALL
+        while (_Oldsize < _Mysize()) {
+            pop_back(); // restore old size, at least
+        }
+        _RERAISE;
+        _CATCH_END
+    }
+#endif // __cpp_lib_containers_ranges
+
     iterator insert(const_iterator _Where, _Ty&& _Val) {
         return emplace(_Where, _STD move(_Val));
     }
@@ -784,23 +857,7 @@ public:
     template <class... _Valty>
     decltype(auto) emplace_front(_Valty&&... _Val) {
         _Orphan_all();
-
-        if (_Myoff() % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
-            _Growmap(1);
-        }
-        _Myoff() &= _Mapsize() * _Block_size - 1;
-        size_type _Newoff = _Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size;
-        size_type _Block  = _Getblock(--_Newoff);
-        if (_Map()[_Block] == nullptr) {
-            _Map()[_Block] = _Getal().allocate(_Block_size);
-        }
-
-        _Alty_traits::construct(
-            _Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size), _STD forward<_Valty>(_Val)...);
-
-        _Myoff() = _Newoff;
-        ++_Mysize();
-
+        _Emplace_front_internal(_STD forward<_Valty>(_Val)...);
 #if _HAS_CXX17
         return front();
 #endif // _HAS_CXX17
@@ -965,8 +1022,9 @@ public:
     }
 
     void resize(_CRT_GUARDOVERFLOW size_type _Newsize) {
+        _Orphan_all();
         while (_Mysize() < _Newsize) {
-            emplace_back();
+            _Emplace_back_internal();
         }
 
         while (_Mysize() > _Newsize) {
@@ -1115,6 +1173,25 @@ private:
         ++_Mysize();
     }
 
+    template <class... _Tys>
+    void _Emplace_front_internal(_Tys&&... _Vals) {
+        if (_Myoff() % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
+            _Growmap(1);
+        }
+        _Myoff() &= _Mapsize() * _Block_size - 1;
+        size_type _Newoff = _Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size;
+        size_type _Block  = _Getblock(--_Newoff);
+        if (_Map()[_Block] == nullptr) {
+            _Map()[_Block] = _Getal().allocate(_Block_size);
+        }
+
+        _Alty_traits::construct(
+            _Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size), _STD forward<_Tys>(_Vals)...);
+
+        _Myoff() = _Newoff;
+        ++_Mysize();
+    }
+
 public:
     void push_back(const _Ty& _Val) {
         _Orphan_all();
@@ -1145,30 +1222,48 @@ public:
 #endif // _ITERATOR_DEBUG_LEVEL == 2
     }
 
-    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
-    void assign(_Iter _First, _Iter _Last) {
+private:
+    template <class _Iter, class _Sent>
+    void _Assign_range(_Iter _First, const _Sent _Last) {
         _Orphan_all();
-        _Adl_verify_range(_First, _Last);
-        auto _UFirst       = _Get_unwrapped(_First);
-        const auto _ULast  = _Get_unwrapped(_Last);
         auto _Myfirst      = _Unchecked_begin();
         const auto _Mylast = _Unchecked_end();
-        for (; _UFirst != _ULast; ++_UFirst) { // try to assign over an element in the container
-            if (_Myfirst == _Mylast) { // container wasn't big enough, insert what's left at end
-                do {
-                    emplace_back(*_UFirst);
-                    ++_UFirst;
-                } while (_UFirst != _ULast);
+        for (;;) { // try to assign over an element in the container
+            if (_First == _Last) {
+                _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
                 return;
             }
 
-            *_Myfirst = *_UFirst;
+            if (_Myfirst == _Mylast) {
+                break;
+            }
+
+            *_Myfirst = *_First;
             ++_Myfirst;
+            ++_First;
         }
 
-        _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
+        // container wasn't big enough, insert what's left at end
+        do {
+            _Emplace_back_internal(*_First);
+            ++_First;
+        } while (_First != _Last);
     }
 
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    void assign(_Iter _First, _Iter _Last) {
+        _Adl_verify_range(_First, _Last);
+        _Assign_range(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+    }
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        _Assign_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) { // assign _Count * _Val
         _Orphan_all();
         auto _Myfirst       = _Unchecked_begin();
@@ -1247,24 +1342,26 @@ public:
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
         _Adl_verify_range(_First, _Last);
-        auto _UFirst      = _Get_unwrapped(_First);
-        const auto _ULast = _Get_unwrapped(_Last);
+        auto _UFirst = _Get_unwrapped(_First);
+        auto _ULast  = _Get_unwrapped(_Last);
 
         size_type _Oldsize = _Mysize();
 
         if (_UFirst != _ULast) {
+            _Orphan_all();
             if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
                 _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
                 for (; _UFirst != _ULast; ++_UFirst) {
-                    emplace_front(*_UFirst); // prepend flipped
+                    _Emplace_front_internal(*_UFirst); // prepend flipped
                 }
 
                 _Guard._Container = nullptr;
 
-                size_type _Num = _Mysize() - _Oldsize;
-                _STD reverse(begin(), begin() + static_cast<difference_type>(_Num)); // flip new stuff in place
-                _STD rotate(begin(), begin() + static_cast<difference_type>(_Num),
-                    begin() + static_cast<difference_type>(_Num + _Off));
+                const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
+                if (!_Is_bidi_iter_v<_Iter>) {
+                    _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+                }
+                _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
             } else { // closer to back
                 _Orphan_all();
                 _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
@@ -1282,6 +1379,71 @@ public:
         return begin() + static_cast<difference_type>(_Off);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        size_type _Off = static_cast<size_type>(_Where - begin());
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        size_type _Oldsize = _Mysize();
+
+        auto _UFirst = _RANGES _Ubegin(_Range);
+        auto _ULast  = [&] {
+            if constexpr (_RANGES bidirectional_range<_Rng>) {
+                return _RANGES _Get_final_iterator_unwrapped(_Range);
+            } else {
+                return _RANGES _Uend(_Range);
+            }
+        }();
+        if (_UFirst != _ULast) {
+            _Orphan_all();
+            if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
+                _TRY_BEGIN
+                if constexpr (_RANGES bidirectional_range<_Rng>) {
+                    while (_UFirst != _ULast) {
+                        _Emplace_front_internal(*--_ULast);
+                    }
+                } else {
+                    for (; _UFirst != _ULast; ++_UFirst) {
+                        _Emplace_front_internal(*_UFirst); // prepend flipped
+                    }
+                }
+                _CATCH_ALL
+                while (_Oldsize < _Mysize()) {
+                    pop_front(); // restore old size, at least
+                }
+                _RERAISE;
+                _CATCH_END
+
+                const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
+                if constexpr (!_RANGES bidirectional_range<_Rng>) {
+                    _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+                }
+                _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
+            } else { // closer to back
+                _TRY_BEGIN
+                for (; _UFirst != _ULast; ++_UFirst) {
+                    _Emplace_back_internal(*_UFirst);
+                }
+                _CATCH_ALL
+                while (_Oldsize < _Mysize()) {
+                    pop_back(); // restore old size, at least
+                }
+                _RERAISE;
+                _CATCH_END
+
+                _STD rotate(begin() + static_cast<difference_type>(_Off),
+                    begin() + static_cast<difference_type>(_Oldsize), end());
+            }
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+#endif // __cpp_lib_containers_ranges
+
     iterator erase(const_iterator _Where) noexcept(is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
         return erase(_Where, _Next_iter(_Where));
     }
@@ -1577,6 +1739,12 @@ template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
 deque(_Iter, _Iter, _Alloc = _Alloc()) -> deque<_Iter_value_t<_Iter>, _Alloc>;
 #endif // _HAS_CXX17
 
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+deque(from_range_t, _Rng&&, _Alloc = _Alloc()) -> deque<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
+
 template <class _Ty, class _Alloc>
 void swap(deque<_Ty, _Alloc>& _Left, deque<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index e334451202..ce143ad6ee 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -463,7 +463,7 @@ struct _Flist_insert_after_op2 {
             ++_First; // throws
         }
 
-        while (_First != _Last) { // throws
+        while (_First != _Last) {
             _Newnode._Allocate(); // throws
             _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
             const auto _Newtail = _Newnode._Release();
@@ -606,6 +606,24 @@ public:
         _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    forward_list(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    forward_list(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+#endif // __cpp_lib_containers_ranges
+
     forward_list(forward_list&& _Right) noexcept // strengthened
         : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
         _Alloc_proxy();
@@ -898,19 +916,26 @@ public:
         _Insert_after(_Mypair._Myval2._Before_head(), _Val);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        insert_range_after(before_begin(), _Range);
+    }
+#endif // __cpp_lib_containers_ranges
+
     void pop_front() noexcept /* strengthened */ {
         _Erase_after(_Mypair._Myval2._Before_head());
     }
 
 private:
     template <class _UIter, class _Sentinel>
-    void _Assign_unchecked(_UIter _UFirst, _Sentinel _ULast) {
+    void _Assign_unchecked(_UIter _UFirst, const _Sentinel _ULast) {
         auto _Myfirst = _Mypair._Myval2._Before_head();
         for (; _UFirst != _ULast; ++_UFirst) {
-            auto _Next = _Myfirst->_Next;
-            if (!_Myfirst->_Next) {
+            const auto _Next = _Myfirst->_Next;
+            if (!_Next) {
                 _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
-                _Insert_op._Append_range_unchecked(_UFirst, _ULast);
+                _Insert_op._Append_range_unchecked(_STD move(_UFirst), _ULast);
                 _Insert_op._Attach_after(_Myfirst);
                 return;
             }
@@ -920,7 +945,7 @@ private:
         }
 
         for (auto _To_delete = _STD exchange(_Myfirst->_Next, nullptr); _To_delete;) {
-            auto _Next = _To_delete->_Next;
+            const auto _Next = _To_delete->_Next;
 #if _ITERATOR_DEBUG_LEVEL == 2
             _Mypair._Myval2._Orphan_ptr(_To_delete);
 #endif // _ITERATOR_DEBUG_LEVEL == 2
@@ -936,6 +961,13 @@ public:
         _Assign_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        _Assign_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
         clear();
         insert_after(before_begin(), _Count, _Val);
@@ -985,6 +1017,26 @@ public:
         return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range_after(const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        auto _UFirst      = _RANGES _Ubegin(_Range);
+        const auto _ULast = _RANGES _Uend(_Range);
+        if (_UFirst == _ULast) {
+            return _Make_iter(_Where._Ptr);
+        }
+
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_STD move(_UFirst), _ULast);
+        return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
+    }
+#endif // __cpp_lib_containers_ranges
+
 private:
     void _Erase_after(_Nodeptr _Pnode) noexcept { // erase element after _Pnode
         auto _Subject = _Pnode->_Next;
@@ -1507,6 +1559,12 @@ template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
 forward_list(_Iter, _Iter, _Alloc = _Alloc()) -> forward_list<_Iter_value_t<_Iter>, _Alloc>;
 #endif // _HAS_CXX17
 
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+forward_list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> forward_list<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
+
 template <class _Ty, class _Alloc>
 void swap(forward_list<_Ty, _Alloc>& _Left, forward_list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
diff --git a/stl/inc/list b/stl/inc/list
index e5d0956d72..3019a625f2 100644
--- a/stl/inc/list
+++ b/stl/inc/list
@@ -848,12 +848,12 @@ public:
     }
 
 private:
-    template <class _Iter>
-    void _Construct_range_unchecked(_Iter _First, _Iter _Last) {
+    template <class _Iter, class _Sent>
+    void _Construct_range_unchecked(_Iter _First, const _Sent _Last) {
         auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Getal());
         _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
         _List_node_insert_op2<_Alnode> _Appended(_Getal());
-        _Appended._Append_range_unchecked(_First, _Last);
+        _Appended._Append_range_unchecked(_STD move(_First), _Last);
         _Appended._Attach_head(_Mypair._Myval2);
         _Proxy._Release();
     }
@@ -880,6 +880,18 @@ public:
         _Construct_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    list(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    list(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     list(list&& _Right) : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
         _Alloc_sentinel_and_proxy();
         _Swap_val(_Right);
@@ -1022,8 +1034,7 @@ public:
         assign(_Ilist.begin(), _Ilist.end());
     }
 
-    iterator insert(const_iterator _Where,
-        initializer_list<_Ty> _Ilist) { // insert initializer_list
+    iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) { // insert initializer_list
         return insert(_Where, _Ilist.begin(), _Ilist.end());
     }
 
@@ -1223,6 +1234,15 @@ public:
         _Emplace(_Mypair._Myval2._Myhead->_Next, _Val);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Op._Attach_before(_Mypair._Myval2, _Mypair._Myval2._Myhead->_Next);
+    }
+#endif // __cpp_lib_containers_ranges
+
     void pop_front() noexcept /* strengthened */ {
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "pop_front called on empty list");
@@ -1235,6 +1255,15 @@ public:
         _Emplace(_Mypair._Myval2._Myhead, _Val);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void append_range(_Rng&& _Range) {
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Op._Attach_at_end(_Mypair._Myval2);
+    }
+#endif // __cpp_lib_containers_ranges
+
     void pop_back() noexcept /* strengthened */ {
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "pop_back called on empty list");
@@ -1270,12 +1299,45 @@ private:
         }
     }
 
+    template <class _Iter, class _Sent>
+    void _Assign_unchecked(_Iter _First, const _Sent _Last) {
+        // assign [_First, _Last)
+        const auto _Myend = _Mypair._Myval2._Myhead;
+        auto _Old         = _Myend->_Next;
+        for (;;) { // attempt to reuse a node
+            if (_First == _Last) {
+                // input sequence exhausted; destroy and deallocate any tail of unneeded nodes
+                _Unchecked_erase(_Old, _Myend);
+                return;
+            }
+
+            if (_Old == _Myend) { // no more nodes to reuse, append the rest
+                _List_node_insert_op2<_Alnode> _Op(_Getal());
+                _Op._Append_range_unchecked(_STD move(_First), _Last);
+                _Op._Attach_at_end(_Mypair._Myval2);
+                return;
+            }
+
+            // reuse the node
+            _Old->_Myval = *_First;
+            _Old         = _Old->_Next;
+            ++_First;
+        }
+    }
+
 public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     void assign(_Iter _First, _Iter _Last) {
-        _Assign_cast<reference>(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+        _Assign_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        _Assign_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) { // assign _Count * _Val
         const auto _Myend = _Mypair._Myval2._Myhead;
         auto _Old         = _Myend->_Next;
@@ -1307,8 +1369,8 @@ public:
         return _Make_iter(_Emplace(_Where._Ptr, _Val));
     }
 
-    iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count,
-        const _Ty& _Val) { // insert _Count * _Val before _Where
+    iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val before _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
@@ -1328,6 +1390,18 @@ public:
         return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
+    }
+#endif // __cpp_lib_containers_ranges
+
 public:
     iterator erase(const const_iterator _Where) noexcept /* strengthened */ {
 #if _ITERATOR_DEBUG_LEVEL == 2
@@ -1783,6 +1857,12 @@ template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
 list(_Iter, _Iter, _Alloc = _Alloc()) -> list<_Iter_value_t<_Iter>, _Alloc>;
 #endif // _HAS_CXX17
 
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> list<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
+
 template <class _Ty, class _Alloc>
 void swap(list<_Ty, _Alloc>& _Left, list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
diff --git a/stl/inc/map b/stl/inc/map
index 66fdd9fc81..96219bd391 100644
--- a/stl/inc/map
+++ b/stl/inc/map
@@ -134,6 +134,28 @@ public:
         insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     map& operator=(const map& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -359,6 +381,18 @@ map(_Iter, _Iter, _Alloc) -> map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, less<
 
 template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
 map(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> map<_Kty, _Ty, less<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Pr = less<_Range_key_type<_Rng>>,
+    class _Alloc = allocator<_Range_to_alloc_type<_Rng>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+map(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
+    -> map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+map(from_range_t, _Rng&&, _Alloc)
+    -> map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Ty, class _Pr, class _Alloc>
@@ -478,6 +512,28 @@ public:
         insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     multimap& operator=(const multimap& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -556,6 +612,18 @@ multimap(_Iter, _Iter, _Alloc) -> multimap<_Guide_key_t<_Iter>, _Guide_val_t<_It
 
 template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
 multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> multimap<_Kty, _Ty, less<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Pr = less<_Range_key_type<_Rng>>,
+    class _Alloc = allocator<_Range_to_alloc_type<_Rng>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multimap(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
+    -> multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+multimap(from_range_t, _Rng&&, _Alloc)
+    -> multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Ty, class _Pr, class _Alloc>
diff --git a/stl/inc/memory b/stl/inc/memory
index 72140847c5..f3a6f925ae 100644
--- a/stl/inc/memory
+++ b/stl/inc/memory
@@ -118,7 +118,7 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _
     auto _UFirst = _Get_unwrapped_n(_First, _Count);
     auto _UDest  = _Get_unwrapped_n(_Dest, _Count);
     if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
-        _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
+        _UDest = _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _UDest);
     } else {
         _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
 
@@ -253,7 +253,7 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count
     auto _UFirst = _Get_unwrapped_n(_First, _Count);
     auto _UDest  = _Get_unwrapped_n(_Dest, _Count);
     if constexpr (_Iter_move_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
-        _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
+        _UDest = _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _UDest);
         _UFirst += _Count;
     } else {
         _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
@@ -2184,7 +2184,7 @@ struct _NODISCARD _Reverse_destroy_multidimensional_n_guard {
 template <class _Ty, size_t _Size>
 void _Uninitialized_copy_multidimensional(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size]) {
     if constexpr (is_trivial_v<_Ty>) {
-        _Copy_memmove(_In, _In + _Size, _Out);
+        _Copy_memmove_n(_In, _Size, _Out);
     } else if constexpr (is_array_v<_Ty>) {
         _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
         for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
@@ -2549,7 +2549,7 @@ template <class _Ty, size_t _Size, class _Alloc>
 void _Uninitialized_copy_multidimensional_al(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size], _Alloc& _Al) {
     using _Item = remove_all_extents_t<_Ty>;
     if constexpr (conjunction_v<is_trivial<_Ty>, _Uses_default_construct<_Alloc, _Item*, const _Item&>>) {
-        _Copy_memmove(_In, _In + _Size, _Out);
+        _Copy_memmove_n(_In, _Size, _Out);
     } else if constexpr (is_array_v<_Ty>) {
         _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
         for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
diff --git a/stl/inc/queue b/stl/inc/queue
index d798d5ed4f..81ee00bf4b 100644
--- a/stl/inc/queue
+++ b/stl/inc/queue
@@ -12,6 +12,10 @@
 #include <deque>
 #include <vector>
 
+#ifdef __cpp_lib_containers_ranges
+#include <ranges>
+#endif // __cpp_lib_containers_ranges
+
 #pragma pack(push, _CRT_PACKING)
 #pragma warning(push, _STL_WARNING_LEVEL)
 #pragma warning(disable : _STL_DISABLED_WARNINGS)
@@ -42,6 +46,11 @@ public:
     template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
     queue(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) // strengthened
         : c(_STD move(_First), _STD move(_Last)) {}
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    queue(from_range_t, _Rng&& _Range) : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))) {}
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
     template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
@@ -70,6 +79,12 @@ public:
     queue(_InIt _First, _InIt _Last, const _Alloc& _Al) noexcept(
         is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) // strengthened
         : c(_STD move(_First), _STD move(_Last), _Al) {}
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+    queue(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
     _NODISCARD bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
@@ -104,6 +119,17 @@ public:
         c.push_back(_STD move(_Val));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) {
+        if constexpr (requires { c.append_range(_Range); }) {
+            c.append_range(_Range);
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     template <class... _Valty>
     decltype(auto) emplace(_Valty&&... _Val) {
 #if _HAS_CXX17
@@ -142,6 +168,13 @@ queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
 template <class _InIt, class _Alloc = allocator<_Iter_value_t<_InIt>>,
     enable_if_t<conjunction_v<_Is_iterator<_InIt>, _Is_allocator<_Alloc>>, int> = 0>
 queue(_InIt, _InIt, _Alloc = _Alloc()) -> queue<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+queue(from_range_t, _Rng&&, _Alloc = _Alloc())
+    -> queue<_RANGES range_value_t<_Rng>, deque<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
 template <class _Ty, class _Container>
@@ -238,6 +271,14 @@ public:
         _STD make_heap(c.begin(), c.end(), comp);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    priority_queue(from_range_t, _Rng&& _Range, const _Pr& _Pred = _Pr())
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))), comp(_Pred) {
+        _STD make_heap(c.begin(), c.end(), comp);
+    }
+#endif // __cpp_lib_containers_ranges
+
     template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
     explicit priority_queue(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>&&
             is_nothrow_default_constructible_v<value_compare>) // strengthened
@@ -296,6 +337,22 @@ public:
         _STD make_heap(c.begin(), c.end(), comp);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc,
+        enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(from_range_t, _Rng&& _Range, const _Pr& _Pred, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)), comp(_Pred) {
+        _STD make_heap(c.begin(), c.end(), comp);
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc,
+        enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)), comp() {
+        _STD make_heap(c.begin(), c.end(), comp);
+    }
+#endif // __cpp_lib_containers_ranges
+
     _NODISCARD bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
         return c.empty();
     }
@@ -318,6 +375,19 @@ public:
         _STD push_heap(c.begin(), c.end(), comp);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) { // LWG issue submitted but unnumbered as of 2022-06-20
+        if constexpr (requires { c.append_range(_Range); }) {
+            c.append_range(_Range);
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+
+        _STD make_heap(c.begin(), c.end(), comp);
+    }
+#endif // __cpp_lib_containers_ranges
+
     template <class... _Valty>
     void emplace(_Valty&&... _Val) {
         c.emplace_back(_STD forward<_Valty>(_Val)...);
@@ -369,6 +439,22 @@ template <class _Iter, class _Compare, class _Container, class _Alloc,
     enable_if_t<conjunction_v<_Is_iterator<_Iter>, uses_allocator<_Container, _Alloc>>, int> = 0>
 priority_queue(_Iter, _Iter, _Compare, _Container, _Alloc)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+    enable_if_t<!_Is_allocator<_Pr>::value, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Pr = _Pr())
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>>, _Pr>;
+
+template <_RANGES input_range _Rng, class _Pr, class _Alloc,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Pr, _Alloc)
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>, _Alloc>, _Pr>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Alloc)
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Ty, class _Container, class _Pr,
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 1cffc0d8a5..99d573250a 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6352,6 +6352,133 @@ namespace ranges {
 
         inline constexpr _Chunk_by_fn chunk_by;
     } // namespace views
+
+#ifdef __cpp_lib_ranges_to_container
+    // clang-format off
+    template <class _Range, class _Container>
+    concept _Sized_and_reservable = sized_range<_Range> && sized_range<_Container>
+        && requires(_Container& _Cont, const _Container& _CCont, const range_size_t<_Container> _Count) {
+            _Cont.reserve(_Count);
+            { _CCont.capacity() } -> same_as<range_size_t<_Container>>;
+            { _CCont.max_size() } -> same_as<range_size_t<_Container>>;
+        };
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Common_constructible = common_range<_Rng> && _Cpp17_input_iterator<iterator_t<_Rng>>
+        && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Constructible_and_insertable = constructible_from<_Container, _Types...>
+        && requires(_Container& _Cont) {
+            requires (
+                requires { _Cont.push_back(_STD declval<range_reference_t<_Rng>>()); }
+                || requires { _Cont.insert(_Cont.end(), _STD declval<range_reference_t<_Rng>>()); });
+        };
+
+    template <class _Reference, class _Container>
+    _NODISCARD constexpr auto _Container_inserter(_Container& _Cont) {
+        if constexpr (requires { _Cont.push_back(_STD declval<_Reference>()); }) {
+            return back_insert_iterator{_Cont};
+        } else {
+            return insert_iterator{_Cont, _Cont.end()};
+        }
+    }
+
+    template <class _Container, input_range _Rng, class... _Types>
+        requires (!view<_Container>)
+    _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {
+        // clang-format on
+        constexpr bool _Ref_converts = convertible_to<range_reference_t<_Rng>, range_value_t<_Container>>;
+        if constexpr (_Ref_converts && constructible_from<_Container, _Rng, _Types...>) {
+            return _Container(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        } else if constexpr (_Ref_converts && constructible_from<_Container, from_range_t, _Rng, _Types...>) {
+            return _Container(from_range, _STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        } else if constexpr (_Ref_converts && _Common_constructible<_Rng, _Container, _Types...>) {
+            return _Container(_RANGES begin(_Range), _RANGES end(_Range), _STD forward<_Types...>(_Args)...);
+        } else if constexpr (_Ref_converts && _Constructible_and_insertable<_Rng, _Container, _Types...>) {
+            _Container _Cont(_STD forward<_Types>(_Args)...);
+            if constexpr (_Sized_and_reservable<_Rng, _Container>) {
+                _Cont.reserve(_RANGES size(_Range));
+            }
+            _RANGES copy(_Range, _Container_inserter<range_reference_t<_Rng>>(_Cont));
+            return _Cont;
+        } else if constexpr (input_range<range_reference_t<_Rng>>) {
+            const auto _Xform = [](auto&& _Elem) {
+                return _RANGES to<range_value_t<_Container>>(_STD forward<decltype(_Elem)>(_Elem));
+            };
+            return _RANGES to<_Container>(views::transform(_Range, _Xform), _STD forward<_Types>(_Args)...);
+        } else {
+            static_assert(_Always_false<_Container>, "the program is ill-formed per N4910 [range.utility.conv.to]/1.3");
+        }
+    }
+
+    template <class _Container>
+    struct _To_class_fn {
+        _STL_INTERNAL_STATIC_ASSERT(!view<_Container>);
+
+        template <input_range _Rng, class... _Types>
+        _NODISCARD constexpr auto operator()(_Rng&& _Range, _Types&&... _Args) const requires requires {
+            _RANGES to<_Container>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        }
+        { return _RANGES to<_Container>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...); }
+    };
+
+    // clang-format off
+    template <class _Container, class... _Types>
+        requires (!view<_Container>)
+    _NODISCARD constexpr auto to(_Types&&... _Args) {
+        return _Range_closure<_To_class_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
+    }
+    // clang-format on
+
+    template <input_range _Rng>
+    struct _Phony_input_iterator {
+        using iterator_category = input_iterator_tag;
+        using value_type        = range_value_t<_Rng>;
+        using difference_type   = ptrdiff_t;
+        using pointer           = add_pointer_t<range_reference_t<_Rng>>;
+        using reference         = range_reference_t<_Rng>;
+
+        reference operator*() const;
+        pointer operator->() const;
+
+        _Phony_input_iterator& operator++();
+        _Phony_input_iterator operator++(int);
+
+        bool operator==(const _Phony_input_iterator&) const;
+    };
+
+    template <template <class...> class _Container, class _Rng, class... _Types>
+    auto _To_helper(int) -> decltype(_Container(_STD declval<_Rng>(), _STD declval<_Types>()...)); // not defined
+
+    template <template <class...> class _Container, class _Rng, class... _Types>
+    auto _To_helper(long)
+        -> decltype(_Container(from_range, _STD declval<_Rng>(), _STD declval<_Types>()...)); // not defined
+
+    template <template <class...> class _Container, class _Rng, class... _Types>
+    auto _To_helper(...) -> decltype(_Container(_STD declval<_Phony_input_iterator<_Rng>>(),
+        _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Types>()...)); // not defined
+
+    template <template <class...> class _Container, input_range _Rng, class... _Types,
+        class _Deduced = decltype(_To_helper<_Container, _Rng, _Types...>(42))>
+    _NODISCARD constexpr _Deduced to(_Rng&& _Range, _Types&&... _Args) {
+        return to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+    }
+
+    template <template <class...> class _Container>
+    struct _To_template_fn {
+        template <input_range _Rng, class... _Types,
+            class _Deduced = decltype(_To_helper<_Container, _Rng, _Types...>(42))>
+        _NODISCARD constexpr auto operator()(_Rng&& _Range, _Types&&... _Args) const {
+            return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        }
+    };
+
+    template <template <class...> class _Container, class... _Types>
+    _NODISCARD constexpr auto to(_Types&&... _Args) {
+        return _Range_closure<_To_template_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
+    }
+#endif // __cpp_lib_ranges_to_container
 #endif // _HAS_CXX23
 } // namespace ranges
 
diff --git a/stl/inc/set b/stl/inc/set
index ffb4c5cf5b..a7ab8aef22 100644
--- a/stl/inc/set
+++ b/stl/inc/set
@@ -111,6 +111,28 @@ public:
         this->insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     set& operator=(const set& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -170,6 +192,16 @@ set(_Iter, _Iter, _Alloc) -> set<_Iter_value_t<_Iter>, less<_Iter_value_t<_Iter>
 
 template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
 set(initializer_list<_Kty>, _Alloc) -> set<_Kty, less<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+set(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+set(from_range_t, _Rng&&, _Alloc) -> set<_RANGES range_value_t<_Rng>, less<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Pr, class _Alloc>
@@ -287,6 +319,28 @@ public:
         this->insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     multiset& operator=(const multiset& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -352,6 +406,17 @@ multiset(_Iter, _Iter, _Alloc) -> multiset<_Iter_value_t<_Iter>, less<_Iter_valu
 
 template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
 multiset(initializer_list<_Kty>, _Alloc) -> multiset<_Kty, less<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multiset(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+multiset(from_range_t, _Rng&&, _Alloc)
+    -> multiset<_RANGES range_value_t<_Rng>, less<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Pr, class _Alloc>
diff --git a/stl/inc/stack b/stl/inc/stack
index 6364392161..dbc01a8e88 100644
--- a/stl/inc/stack
+++ b/stl/inc/stack
@@ -10,6 +10,10 @@
 #if _STL_COMPILER_PREPROCESSOR
 #include <deque>
 
+#ifdef __cpp_lib_containers_ranges
+#include <ranges>
+#endif // __cpp_lib_containers_ranges
+
 #pragma pack(push, _CRT_PACKING)
 #pragma warning(push, _STL_WARNING_LEVEL)
 #pragma warning(disable : _STL_DISABLED_WARNINGS)
@@ -40,6 +44,11 @@ public:
     template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
     stack(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) // strengthened
         : c(_STD move(_First), _STD move(_Last)) {}
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    stack(from_range_t, _Rng&& _Range) : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))) {}
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
     template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
@@ -68,6 +77,12 @@ public:
     stack(_InIt _First, _InIt _Last, const _Alloc& _Al) noexcept(
         is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) // strengthened
         : c(_STD move(_First), _STD move(_Last), _Al) {}
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+    stack(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
     _NODISCARD bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
@@ -94,6 +109,17 @@ public:
         c.push_back(_STD move(_Val));
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) {
+        if constexpr (requires { c.append_range(_Range); }) {
+            c.append_range(_Range);
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     template <class... _Valty>
     decltype(auto) emplace(_Valty&&... _Val) {
 #if _HAS_CXX17
@@ -132,6 +158,14 @@ stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;
 template <class _InIt, class _Alloc = allocator<_Iter_value_t<_InIt>>,
     enable_if_t<conjunction_v<_Is_iterator<_InIt>, _Is_allocator<_Alloc>>, int> = 0>
 stack(_InIt, _InIt, _Alloc = _Alloc()) -> stack<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng>
+stack(from_range_t, _Rng&&) -> stack<_RANGES range_value_t<_Rng>>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+stack(from_range_t, _Rng&&, _Alloc) -> stack<_RANGES range_value_t<_Rng>, deque<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX23
 
 template <class _Ty, class _Container>
diff --git a/stl/inc/unordered_map b/stl/inc/unordered_map
index d5c868d480..4fca6fd7e2 100644
--- a/stl/inc/unordered_map
+++ b/stl/inc/unordered_map
@@ -190,6 +190,60 @@ public:
         insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     unordered_map& operator=(const unordered_map& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -444,6 +498,27 @@ template <class _Kty, class _Ty, class _Hasher, class _Alloc,
     enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
 unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
     -> unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Hasher = hash<_Range_key_type<_Rng>>,
+    class _Keyeq = equal_to<_Range_key_type<_Rng>>, class _Alloc = allocator<_Range_to_alloc_type<_Rng>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(from_range_t, _Rng&&, _Alloc) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
@@ -599,6 +674,61 @@ public:
         insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     unordered_multimap& operator=(const unordered_multimap& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -735,6 +865,29 @@ template <class _Kty, class _Ty, class _Hasher, class _Alloc,
     enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
 unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
     -> unordered_multimap<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Hasher = hash<_Range_key_type<_Rng>>,
+    class _Keyeq = equal_to<_Range_key_type<_Rng>>, class _Alloc = allocator<_Range_to_alloc_type<_Rng>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>,
+        equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(from_range_t, _Rng&&, _Alloc) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>,
+        _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
diff --git a/stl/inc/unordered_set b/stl/inc/unordered_set
index 1d8e6716df..c54eafea51 100644
--- a/stl/inc/unordered_set
+++ b/stl/inc/unordered_set
@@ -184,6 +184,60 @@ public:
         this->insert(_First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     unordered_set& operator=(const unordered_set& _Right) {
         _Mybase::operator=(_Right);
         return *this;
@@ -298,6 +352,27 @@ template <class _Kty, class _Hasher, class _Alloc,
     enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
 unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
     -> unordered_set<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    class _Keyeq = equal_to<_RANGES range_value_t<_Rng>>, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_set(from_range_t, _Rng&&, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
@@ -455,6 +530,61 @@ public:
 
     unordered_multiset(unordered_multiset&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     unordered_multiset& operator=(unordered_multiset&& _Right) noexcept(_Alnode_traits::is_always_equal::value&&
             is_nothrow_move_assignable_v<_Hasher>&& is_nothrow_move_assignable_v<_Keyeq>) {
         _Mybase::operator=(_STD move(_Right));
@@ -561,6 +691,28 @@ template <class _Kty, class _Hasher, class _Alloc,
     enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
 unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
     -> unordered_multiset<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    class _Keyeq = equal_to<_RANGES range_value_t<_Rng>>, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, hash<_RANGES range_value_t<_Rng>>,
+        equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multiset(from_range_t, _Rng&&, _Alloc) -> unordered_multiset<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
diff --git a/stl/inc/vector b/stl/inc/vector
index efa9abcf35..00ad8cac29 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -699,7 +699,8 @@ public:
             _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
 #ifdef __cpp_lib_concepts
         } else if constexpr (forward_iterator<_Iter>) {
-            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES distance(_UFirst, _ULast)));
+            const auto _Length = _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
             _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
 #endif // __cpp_lib_concepts
         } else {
@@ -722,6 +723,32 @@ public:
         _Construct_n(_Convert_size<size_type>(_Ilist.size()), _Ilist.begin(), _Ilist.end());
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        } else {
+            auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+            _Tidy_guard<vector> _Guard{this};
+
+            auto _UFirst      = _RANGES _Ubegin(_Range);
+            const auto _ULast = _RANGES _Uend(_Range);
+            for (; _UFirst != _ULast; ++_UFirst) {
+                // performance note: _Emplace_one_at_back's strong guarantee is unnecessary here.
+                _Emplace_one_at_back(*_UFirst);
+            }
+
+            _Guard._Target = nullptr;
+            _Proxy._Release();
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 vector(const vector& _Right)
         : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
         const auto& _Right_data = _Right._Mypair._Myval2;
@@ -913,14 +940,100 @@ public:
     }
 
     _CONSTEXPR20 void push_back(const _Ty& _Val) { // insert element at end, provide strong guarantee
-        emplace_back(_Val);
+        _Emplace_one_at_back(_Val);
     }
 
     _CONSTEXPR20 void push_back(_Ty&& _Val) {
         // insert by moving into element at end, provide strong guarantee
-        emplace_back(_STD move(_Val));
+        _Emplace_one_at_back(_STD move(_Val));
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Append_uncounted_range(_Iter _First, const _Sent _Last) {
+        // insert range [_First, _Last) at end
+
+        // For one-at-back, provide strong guarantee.
+        // Otherwise, provide basic guarantee (despite N4659 26.3.11.5 [vector.modifiers]/1).
+        // Performance note: except for one-at-back, _Emplace_one_at_back()'s strong guarantee is unnecessary here.
+
+        for (; _First != _Last; ++_First) {
+            _Emplace_one_at_back(*_First);
+        }
+    }
+
+#ifdef __cpp_lib_containers_ranges
+    template <class _Iter>
+    _CONSTEXPR20 void _Append_counted_range(_Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at end
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst     = _My_data._Myfirst;
+        const pointer _Oldlast      = _Mylast;
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize     = _Oldsize + _Count;
+            const size_type _Newcapacity = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _Al.allocate(_Newcapacity);
+            const pointer _Constructed_last = _Newvec + _Oldsize + _Count;
+            pointer _Constructed_first      = _Constructed_last;
+
+            _TRY_BEGIN
+            _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Oldsize, _Al);
+            _Constructed_first = _Newvec + _Oldsize;
+
+            if (_Count == 1) { // one at back, provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+            }
+            _CATCH_ALL
+            _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+            _Al.deallocate(_Newvec, _Newcapacity);
+            _RERAISE;
+            _CATCH_END
+
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else { // Provide the strong guarantee.
+                 // Performance note: except for one-at-back, the strong guarantee is unnecessary here.
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
+            _Mylast = _Uninitialized_copy_n(_STD move(_First), _Count, _Oldlast, _Al);
+            _ASAN_VECTOR_RELEASE_GUARD;
+
+            _Orphan_range(_Oldlast, _Oldlast);
+        }
+    }
+
+public:
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Append_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
     }
+#endif // __cpp_lib_containers_ranges
 
+public:
     template <class... _Valty>
     _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
         // insert by perfectly forwarding _Val at _Where
@@ -1043,9 +1156,9 @@ public:
     }
 
 private:
-    template <class _Iter>
-    _CONSTEXPR20 void _Insert_input_range(const_iterator _Where, _Iter _First, _Iter _Last) {
-        // insert input range [_First, _Last) at _Where
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Insert_uncounted_range(const_iterator _Where, _Iter _First, _Sent _Last) {
+        // insert range [_First, _Last) at _Where
         if (_First == _Last) {
             return; // nothing to do, avoid invalidating iterators
         }
@@ -1056,13 +1169,7 @@ private:
         const auto _Whereoff = static_cast<size_type>(_Where._Ptr - _Myfirst);
         const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
 
-        // For one-at-back, provide strong guarantee.
-        // Otherwise, provide basic guarantee (despite N4659 26.3.11.5 [vector.modifiers]/1).
-        // Performance note: except for one-at-back, _Emplace_one_at_back()'s strong guarantee is unnecessary here.
-
-        for (; _First != _Last; ++_First) {
-            _Emplace_one_at_back(*_First);
-        }
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
 
         _Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);
 
@@ -1070,18 +1177,9 @@ private:
     }
 
     template <class _Iter>
-    _CONSTEXPR20 void _Insert_forward_range(const_iterator _Where, _Iter _First, _Iter _Last) {
-        // insert forward range [_First, _Last) at _Where
+    _CONSTEXPR20 void _Insert_counted_range(const_iterator _Where, _Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at _Where
         const pointer _Whereptr = _Where._Ptr;
-        size_type _Count;
-#ifdef __cpp_lib_concepts
-        if constexpr (forward_iterator<_Iter>) {
-            _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES distance(_First, _Last)));
-        } else
-#endif // __cpp_lib_concepts
-        {
-            _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
-        }
 
         auto& _Al        = _Getal();
         auto& _My_data   = _Mypair._Myval2;
@@ -1108,7 +1206,7 @@ private:
             pointer _Constructed_first      = _Constructed_last;
 
             _TRY_BEGIN
-            _Uninitialized_copy(_First, _Last, _Newvec + _Whereoff, _Al);
+            _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Whereoff, _Al);
             _Constructed_first = _Newvec + _Whereoff;
 
             if (_Count == 1 && _Whereptr == _Oldlast) { // one at back, provide strong guarantee
@@ -1142,7 +1240,7 @@ private:
                 _Destroy_range(_Whereptr, _Whereptr + _Count, _Al);
 
                 _TRY_BEGIN
-                _Uninitialized_copy(_First, _Last, _Whereptr, _Al);
+                _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
                 _CATCH_ALL
                 // glue the broken pieces back together
 
@@ -1167,7 +1265,7 @@ private:
                 _Destroy_range(_Whereptr, _Oldlast, _Al);
 
                 _TRY_BEGIN
-                _Uninitialized_copy(_First, _Last, _Whereptr, _Al);
+                _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
                 _CATCH_ALL
                 // glue the broken pieces back together
 
@@ -1205,22 +1303,62 @@ public:
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
         _Adl_verify_range(_First, _Last);
+        auto _UFirst         = _Get_unwrapped(_First);
+        auto _ULast          = _Get_unwrapped(_Last);
         const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+        if constexpr (_Is_fwd_iter_v<_Iter>) {
+            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_UFirst, _ULast)));
+            _Insert_counted_range(_Where, _UFirst, _Count);
 #ifdef __cpp_lib_concepts
-        constexpr bool _Is_fwd = _Is_fwd_iter_v<_Iter> || forward_iterator<_Iter>;
-#else // ^^^ __cpp_lib_concepts ^^^ / vvv !__cpp_lib_concepts vvv
-        constexpr bool _Is_fwd = _Is_fwd_iter_v<_Iter>;
-#endif // ^^^ !__cpp_lib_concepts ^^^
-        if constexpr (_Is_fwd) {
-            _Insert_forward_range(_Where, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _UFirst, _Count);
+#endif // __cpp_lib_concepts
         } else {
-            _Insert_input_range(_Where, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+            _Insert_uncounted_range(_Where, _UFirst, _ULast);
         }
         return _Make_iterator_offset(_Whereoff);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert_range iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Insert_uncounted_range(_Where, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+        return _Make_iterator_offset(_Whereoff);
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
-        return insert(_Where, _Ilist.begin(), _Ilist.end());
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Insert_counted_range(_Where, _Ilist.begin(), _Count);
+        return _Make_iterator_offset(_Whereoff);
     }
 
     _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val) {
@@ -1269,9 +1407,9 @@ public:
     }
 
 private:
-    template <class _Iter>
-    _CONSTEXPR20 void _Assign_input_range(_Iter _First, _Iter _Last) {
-        // assign input range [_First, _Last)
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Assign_uncounted_range(_Iter _First, _Sent _Last) {
+        // assign unknown number of elements from [_First, _Last)
         auto& _My_data    = _Mypair._Myval2;
         pointer& _Myfirst = _My_data._Myfirst;
         pointer& _Mylast  = _My_data._Mylast;
@@ -1293,25 +1431,12 @@ private:
         _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Next - _Mylast)); // negative when destroying elements
         _Mylast = _Next;
 
-        // Append.
-        for (; _First != _Last; ++_First) {
-            // performance note: _Emplace_one_at_back()'s strong guarantee is unnecessary here
-            _Emplace_one_at_back(*_First);
-        }
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
     }
 
     template <class _Iter>
-    _CONSTEXPR20 void _Assign_forward_range(_Iter _First, _Iter _Last) {
-        // assign forward range [_First, _Last)
-        size_type _Newsize;
-#ifdef __cpp_lib_concepts
-        if constexpr (forward_iterator<_Iter>) {
-            _Newsize = _Convert_size<size_type>(_To_unsigned_like(_RANGES distance(_First, _Last)));
-        } else
-#endif // __cpp_lib_concepts
-        {
-            _Newsize = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
-        }
+    _CONSTEXPR20 void _Assign_counted_range(_Iter _First, const size_type _Newsize) {
+        // assign elements from counted range _First + [0, _Newsize)
         auto& _Al         = _Getal();
         auto& _My_data    = _Mypair._Myval2;
         pointer& _Myfirst = _My_data._Myfirst;
@@ -1326,32 +1451,52 @@ private:
         if (_Newsize > _Oldcapacity) {
             _Clear_and_reserve_geometric(_Newsize);
             if constexpr (_Nothrow_construct) {
-                _Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
+                _Mylast = _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
                 _ASAN_VECTOR_CREATE;
             } else {
                 _ASAN_VECTOR_CREATE_GUARD;
-                _Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
+                _Mylast = _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
             }
             return;
         }
 
         const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
         if (_Newsize > _Oldsize) {
-            // performance note: traversing [_First, _Mid) twice
-            const _Iter _Mid = _STD next(_First, static_cast<difference_type>(_Oldsize));
-            _Copy_unchecked(_First, _Mid, _Myfirst);
+#if _HAS_CXX20
+            constexpr
+#endif // _HAS_CXX20
+                auto _Copy_n_helper = [](_Iter _In, size_type _Count, pointer _Out) {
+                    // copy _In + [0, _Count) to _Out, returning _In + _Count
+                    // (This is _Copy_n_unchecked, except it returns _In instead of _Out.)
+                    if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+                        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+                        {
+                            _Copy_memmove_n(_In, _Count, _Out);
+                            return _In + _Count;
+                        }
+                    }
+
+                    for (; _Count != 0; ++_Out, (void) ++_In, --_Count) {
+                        *_Out = *_In;
+                    }
 
+                    return _In;
+                };
+
+            _First = _Copy_n_helper(_STD move(_First), _Oldsize, _Myfirst);
             if constexpr (_Nothrow_construct) {
                 _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
-                _Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
+                _Mylast = _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
             } else {
                 _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
-                _Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
+                _Mylast = _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
                 _ASAN_VECTOR_RELEASE_GUARD;
             }
         } else {
             const pointer _Newlast = _Myfirst + _Newsize;
-            _Copy_unchecked(_First, _Last, _Myfirst);
+            _Copy_n_unchecked(_STD move(_First), _Newsize, _Myfirst);
             _Destroy_range(_Newlast, _Mylast, _Al);
             _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
             _Mylast = _Newlast;
@@ -1362,20 +1507,40 @@ public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     _CONSTEXPR20 void assign(_Iter _First, _Iter _Last) {
         _Adl_verify_range(_First, _Last);
+        auto _UFirst = _Get_unwrapped(_First);
+        auto _ULast  = _Get_unwrapped(_Last);
+        if constexpr (_Is_fwd_iter_v<_Iter>) {
+            using _SizeTy      = make_unsigned_t<typename iterator_traits<_Iter>::difference_type>;
+            const auto _Length = static_cast<_SizeTy>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
 #ifdef __cpp_lib_concepts
-        constexpr bool _Is_fwd = _Is_fwd_iter_v<_Iter> || forward_iterator<_Iter>;
-#else // ^^^ __cpp_lib_concepts ^^^ / vvv !__cpp_lib_concepts vvv
-        constexpr bool _Is_fwd = _Is_fwd_iter_v<_Iter>;
-#endif // ^^^ !__cpp_lib_concepts ^^^
-        if constexpr (_Is_fwd) {
-            _Assign_forward_range(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
+#endif // __cpp_lib_concepts
+        } else {
+            _Assign_uncounted_range(_UFirst, _ULast);
+        }
+    }
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
         } else {
-            _Assign_input_range(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
         }
     }
+#endif // __cpp_lib_containers_ranges
 
-    _CONSTEXPR20 void assign(initializer_list<_Ty> _Ilist) {
-        _Assign_forward_range(_Ilist.begin(), _Ilist.end());
+    _CONSTEXPR20 void assign(const initializer_list<_Ty> _Ilist) {
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
     }
 
 public:
@@ -1395,13 +1560,14 @@ public:
 
         _Pocca(_Al, _Right_al);
         auto& _Right_data = _Right._Mypair._Myval2;
-        assign(_Right_data._Myfirst, _Right_data._Mylast);
+        _Assign_counted_range(_Right_data._Myfirst, static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst));
 
         return *this;
     }
 
     _CONSTEXPR20 vector& operator=(initializer_list<_Ty> _Ilist) {
-        _Assign_forward_range(_Ilist.begin(), _Ilist.end());
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
         return *this;
     }
 
@@ -2103,6 +2269,12 @@ template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
 vector(_Iter, _Iter, _Alloc = _Alloc()) -> vector<_Iter_value_t<_Iter>, _Alloc>;
 #endif // _HAS_CXX17
 
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+vector(from_range_t, _Rng&&, _Alloc = _Alloc()) -> vector<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
+
 template <class _Alloc>
 class vector<bool, _Alloc>;
 
@@ -2731,6 +2903,11 @@ public:
         return (_Count + _VBITS - 1) / _VBITS;
     }
 
+    _CONSTEXPR20 void _Emplace_back_unchecked(const _Vbase _Val) noexcept {
+        _STL_INTERNAL_CHECK(_Myvec.size() < _Myvec.capacity());
+        _Myvec._Emplace_back_with_unused_capacity(_Val);
+    }
+
     _Vectype _Myvec; // base vector of words
     size_type _Mysize; // current length of sequence
 };
@@ -2792,6 +2969,19 @@ public:
         insert(begin(), _First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 vector(vector&& _Right) noexcept(is_nothrow_move_constructible_v<_Mybase>) // strengthened
         : _Mybase(_STD move(_Right)) {
         this->_Swap_proxy_and_iterators(_Right);
@@ -3118,6 +3308,13 @@ public:
         insert(end(), _Val);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        insert_range(end(), _STD forward<_Rng>(_Range));
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
         erase(end() - 1);
     }
@@ -3128,13 +3325,73 @@ public:
         insert(begin(), _First, _Last);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <class _Iter>
+    constexpr void _Assign_counted_range(_Iter _First, const size_type _Count) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        this->_Myvec.reserve(this->_Nw(_Count));
+        _Vbase _Accum = 0;
+        _Vbase _Mask  = 1;
+        for (size_type _Idx = 0; _Idx < _Count; ++_Idx) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Emplace_back_unchecked(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Emplace_back_unchecked(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <class _Iter, class _Sent>
+    constexpr void _Assign_uncounted_range(_Iter _First, const _Sent _Last) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        size_type _Count = 0;
+        _Vbase _Accum    = 0;
+        _Vbase _Mask     = 1;
+        for (; _First != _Last; ++_Count) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Myvec.push_back(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Myvec.push_back(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        clear();
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
         clear();
         _Insert_n(begin(), _Count, _Val);
     }
 
     _CONSTEXPR20 iterator insert(const_iterator _Where, const bool& _Val) {
-        return _Insert_n(_Where, static_cast<size_type>(1), _Val);
+        return _Insert_n(_Where, size_type{1}, _Val);
     }
 
     _CONSTEXPR20 iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
@@ -3144,24 +3401,47 @@ public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     _CONSTEXPR20 iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
         const difference_type _Saved_offset = _Where - begin();
+        _Adl_verify_range(_First, _Last);
+        auto _UFirst      = _Get_unwrapped(_First);
+        const auto _ULast = _Get_unwrapped(_Last);
 
         if constexpr (_Is_fwd_iter_v<_Iter>) {
-            _Adl_verify_range(_First, _Last);
-            const auto _Count    = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
-            const size_type _Off = _Insert_x(_Where, _Count);
-            _Copy_unchecked(
-                _Get_unwrapped(_First), _Get_unwrapped(_Last), begin() + static_cast<difference_type>(_Off));
+            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_UFirst, _ULast)));
+            const auto _Off   = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
         } else {
             difference_type _Off = _Saved_offset;
 
-            for (; _First != _Last; ++_First, (void) ++_Off) {
-                insert(begin() + _Off, *_First);
+            for (; _UFirst != _ULast; ++_UFirst, (void) ++_Off) {
+                insert(begin() + _Off, *_UFirst);
             }
         }
 
         return begin() + _Saved_offset;
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const difference_type _Old_off = _Where - begin();
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _Copy_n_unchecked(_RANGES _Ubegin(_Range), _Count, begin() + _Off);
+        } else {
+            auto _UFirst      = _RANGES _Ubegin(_Range);
+            const auto _ULast = _RANGES _Uend(_Range);
+            for (difference_type _Off = _Old_off; _UFirst != _ULast; ++_UFirst, (void) ++_Off) {
+                insert(begin() + _Off, *_UFirst);
+            }
+        }
+
+        return begin() + _Old_off;
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 iterator erase(const_iterator _Where_arg) noexcept /* strengthened */ {
         iterator _Where      = _Make_iter(_Where_arg);
         difference_type _Off = _Where - begin();
@@ -3239,11 +3519,11 @@ public:
     }
 
     _CONSTEXPR20 size_type _Insert_x(const_iterator _Where, size_type _Count) {
-        difference_type _Off = _Where - begin();
+        const difference_type _Off = _Where - begin();
 
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(end() >= _Where, "vector<bool> insert iterator outside range");
-        bool _Realloc = capacity() - size() < _Count;
+        const bool _Realloc = capacity() - size() < _Count;
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
         if (_Count != 0) {
diff --git a/stl/inc/xhash b/stl/inc/xhash
index d17a7905de..5b289214bc 100644
--- a/stl/inc/xhash
+++ b/stl/inc/xhash
@@ -379,7 +379,7 @@ protected:
           _Maxidx(_Right._Maxidx) {
         // construct hash table by copying _Right
         _Vec._Assign_grow(_Right._Vec.size(), _List._Unchecked_end());
-        insert(_Right._Unchecked_begin(), _Right._Unchecked_end());
+        _Insert_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
 #ifdef _ENABLE_STL_INTERNAL_CHECK
         _Stl_internal_check_container_invariants();
         _Right._Stl_internal_check_container_invariants();
@@ -937,18 +937,30 @@ public:
         return emplace_hint(_Hint, _STD move(_Val));
     }
 
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        for (; _First != _Last; ++_First) {
+            emplace(*_First);
+        }
+    }
+
+public:
     template <class _Iter>
     void insert(_Iter _First, _Iter _Last) {
         _Adl_verify_range(_First, _Last);
-        auto _UFirst      = _Get_unwrapped(_First);
-        const auto _ULast = _Get_unwrapped(_Last);
-        for (; _UFirst != _ULast; ++_UFirst) {
-            emplace(*_UFirst);
-        }
+        _Insert_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+    }
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
+#endif // __cpp_lib_containers_ranges
 
     void insert(initializer_list<value_type> _Ilist) {
-        insert(_Ilist.begin(), _Ilist.end());
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
     }
 
 private:
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 30e2493653..be2c5f2cb4 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -1676,24 +1676,39 @@ private:
     _Alloc& _Al;
 };
 
-template <class _InIt, class _Alloc>
+template <class _InIt, class _Se, class _Alloc>
 _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
-    const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    _InIt _First, _Se _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
     // copy [_First, _Last) to raw _Dest, using _Al
     // note: only called internally from elsewhere in the STL
     using _Ptrval = typename _Alloc::value_type*;
 
-    auto _UFirst      = _Get_unwrapped(_First);
-    const auto _ULast = _Get_unwrapped(_Last);
+    auto _UFirst      = _Get_unwrapped(_STD move(_First));
+    const auto _ULast = _Get_unwrapped(_STD move(_Last));
+
+    constexpr bool _Same_types = is_same_v<const decltype(_UFirst), decltype(_ULast)>;
+    constexpr bool _Can_memmove =
+        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>, //
+        _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>
+        && (_Same_types
+#ifdef __cpp_lib_ranges
+            || sized_sentinel_for<remove_const_t<decltype(_ULast)>, decltype(_UFirst)>
+#endif // __cpp_lib_ranges
+        );
 
-    if constexpr (conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
-                      _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>) {
+    if constexpr (_Can_memmove) {
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
-            _Dest += _ULast - _UFirst;
+            if constexpr (_Same_types) {
+                _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
+                _Dest += _ULast - _UFirst;
+            } else {
+                const auto _Count = static_cast<size_t>(_ULast - _UFirst);
+                _Copy_memmove_n(_UFirst, _Count, _Unfancy(_Dest));
+                _Dest += _Count;
+            }
             return _Dest;
         }
     }
@@ -1706,6 +1721,38 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
     return _Backout._Release();
 }
 
+template <class _InIt, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy_n(
+    _InIt _First, size_t _Count, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // copy _First +[0, _Count) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval = typename _Alloc::value_type*;
+
+    auto _UFirst = _Get_unwrapped(_STD move(_First));
+
+    constexpr bool _Can_memmove =
+        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
+            _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>;
+
+    if constexpr (_Can_memmove) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _Copy_memmove_n(_UFirst, _Count, _Unfancy(_Dest));
+            _Dest += _Count;
+            return _Dest;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _Count != 0; ++_UFirst, (void) --_Count) {
+        _Backout._Emplace_back(*_UFirst);
+    }
+
+    return _Backout._Release();
+}
+
 template <class _InIt, class _NoThrowFwdIt>
 _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // copy [_First, _Last) to raw [_Dest, ...)
@@ -2278,6 +2325,27 @@ constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc&
         _STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
 }
 #endif // _HAS_CXX20
+
+#ifdef __cpp_lib_containers_ranges
+struct from_range_t {
+    explicit from_range_t() = default;
+};
+inline constexpr from_range_t from_range;
+
+template <class _Rng, class _Elem>
+concept _Container_compatible_range =
+    _RANGES input_range<_Rng> && convertible_to<_RANGES range_reference_t<_Rng>, _Elem>;
+
+template <_RANGES input_range _Rng>
+using _Range_key_type = remove_const_t<typename _RANGES range_value_t<_Rng>::first_type>;
+
+template <_RANGES input_range _Rng>
+using _Range_mapped_type = typename _RANGES range_value_t<_Rng>::second_type;
+
+template <_RANGES input_range _Rng>
+using _Range_to_alloc_type =
+    pair<const typename _RANGES range_value_t<_Rng>::first_type, typename _RANGES range_value_t<_Rng>::second_type>;
+#endif // __cpp_lib_containers_ranges
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/xstring b/stl/inc/xstring
index ac4775179b..5d0323b8c8 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2815,6 +2815,51 @@ private:
     }
 
 public:
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        _Tidy_init();
+
+        if constexpr (_RANGES sized_range<_Rng>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+
+            if constexpr (contiguous_iterator<decltype(_RANGES _Ubegin(
+                              _Range))> && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+                if (_Count != 0) {
+                    const auto _Ptr = _STD to_address(_RANGES _Ubegin(_Range));
+                    assign(_Ptr, _Count);
+                }
+            } else {
+                reserve(_Count);
+                _Tidy_deallocate_guard<basic_string> _Guard{this};
+                auto _First      = _RANGES _Ubegin(_Range);
+                const auto _Last = _RANGES _Uend(_Range);
+
+                for (; _First != _Last; ++_First) {
+                    _Push_back_unchecked(*_First);
+                }
+
+                _Guard._Target = nullptr;
+            }
+        } else {
+            _Tidy_deallocate_guard<basic_string> _Guard{this};
+            auto _First      = _RANGES _Ubegin(_Range);
+            const auto _Last = _RANGES _Uend(_Range);
+
+            for (; _First != _Last; ++_First) {
+                push_back(*_First);
+            }
+
+            _Guard._Target = nullptr;
+        }
+
+        _Proxy._Release();
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 basic_string(basic_string&& _Right) noexcept
         : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
         _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
@@ -3389,6 +3434,21 @@ public:
         }
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& append_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))> //
+                      && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
+            return append(_Ptr, _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 basic_string& assign(const basic_string& _Right) {
         *this = _Right;
         return *this;
@@ -3481,6 +3541,29 @@ public:
         }
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& assign_range(_Rng&& _Range) {
+        // clang-format off
+        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
+            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+            // clang-format on
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
+            return assign(_Ptr, _Count);
+        } else {
+            basic_string _Right(from_range, _Range, get_allocator());
+            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
+                _Mypair._Myval2._Orphan_all();
+                _Swap_data(_Right);
+                return *this;
+            } else {
+                return assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+            }
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 basic_string& insert(const size_type _Off, const basic_string& _Right) {
         // insert _Right at _Off
         return insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
@@ -3517,8 +3600,8 @@ public:
         _Mypair._Myval2._Check_offset(_Off);
         const size_type _Old_size = _Mypair._Myval2._Mysize;
 
-        // checking for overlapping ranges is technically UB (considering string literals), so just always reallocate
-        // and copy to the new buffer if constant evaluated
+        // checking for overlapping ranges is technically UB (considering string literals), so just always
+        // reallocate and copy to the new buffer if constant evaluated
 #if _HAS_CXX20
         const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size && !_STD is_constant_evaluated();
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
@@ -3631,6 +3714,30 @@ public:
         return begin() + static_cast<difference_type>(_Off);
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr iterator insert_range(const const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+
+        // clang-format off
+        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
+            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+            // clang-format on
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
+            insert(_Off, _Ptr, _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 basic_string& erase(const size_type _Off = 0) { // erase elements [_Off, ...)
         _Mypair._Myval2._Check_offset(_Off);
         _Eos(_Off);
@@ -3734,8 +3841,8 @@ public:
 
         const size_type _Growth = static_cast<size_type>(_Count - _Nx);
 
-        // checking for overlapping ranges is technically UB (considering string literals), so just always reallocate
-        // and copy to the new buffer if constant evaluated
+        // checking for overlapping ranges is technically UB (considering string literals), so just always
+        // reallocate and copy to the new buffer if constant evaluated
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
@@ -3895,6 +4002,30 @@ public:
         }
     }
 
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& replace_with_range(const const_iterator _First, const const_iterator _Last, _Rng&& _Range) {
+        _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off    = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+
+        // clang-format off
+        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
+            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+            // clang-format on
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
+            return replace(_Off, _Length, _Ptr, _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // __cpp_lib_containers_ranges
+
     _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
         return iterator(_Refancy<pointer>(_Mypair._Myval2._Myptr()), _STD addressof(_Mypair._Myval2));
     }
@@ -4028,6 +4159,20 @@ public:
     }
 #endif // _HAS_CXX17
 
+#ifdef __cpp_lib_containers_ranges
+private:
+    constexpr void _Push_back_unchecked(const _Elem _Ch) { // insert element at end; assume available capacity
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        _STL_INTERNAL_CHECK(_Old_size < _Mypair._Myval2._Myres);
+        _Mypair._Myval2._Mysize = _Old_size + 1;
+        _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
+        _Traits::assign(_Ptr[_Old_size], _Ch);
+        _Traits::assign(_Ptr[_Old_size + 1], _Elem());
+    }
+
+public:
+#endif // __cpp_lib_containers_ranges
+
     _CONSTEXPR20 void push_back(const _Elem _Ch) { // insert element at end
         const size_type _Old_size = _Mypair._Myval2._Mysize;
         if (_Old_size < _Mypair._Myval2._Myres) {
@@ -4879,6 +5024,13 @@ template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
     enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
 basic_string(basic_string_view<_Elem, _Traits>, _Guide_size_type_t<_Alloc>, _Guide_size_type_t<_Alloc>,
     const _Alloc& = _Alloc()) -> basic_string<_Elem, _Traits, _Alloc>;
+
+#ifdef __cpp_lib_containers_ranges
+template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value_t<_Rng>>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+basic_string(from_range_t, _Rng&&, _Alloc = _Alloc())
+    -> basic_string<_RANGES range_value_t<_Rng>, char_traits<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // __cpp_lib_containers_ranges
 #endif // _HAS_CXX17
 
 template <class _Elem, class _Traits, class _Alloc>
diff --git a/stl/inc/xtree b/stl/inc/xtree
index 106ab11eea..a0da9d6f5f 100644
--- a/stl/inc/xtree
+++ b/stl/inc/xtree
@@ -1250,19 +1250,31 @@ public:
         return iterator(_Emplace_hint(_Where._Ptr, _STD move(_Val)), _Scary);
     }
 
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        auto _Hint = _Get_scary()->_Myhead;
+        for (; _First != _Last; ++_First) {
+            _Hint = _Emplace_hint(_Hint, *_First);
+        }
+    }
+
+public:
     template <class _Iter>
     void insert(_Iter _First, _Iter _Last) {
         _Adl_verify_range(_First, _Last);
-        auto _UFirst       = _Get_unwrapped(_First);
-        const auto _ULast  = _Get_unwrapped(_Last);
-        const auto _Myhead = _Get_scary()->_Myhead;
-        for (; _UFirst != _ULast; ++_UFirst) {
-            _Emplace_hint(_Myhead, *_UFirst);
-        }
+        _Insert_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
+    }
+
+#ifdef __cpp_lib_containers_ranges
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
+#endif // __cpp_lib_containers_ranges
 
     void insert(initializer_list<value_type> _Ilist) {
-        insert(_Ilist.begin(), _Ilist.end());
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
     }
 
 private:
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 92813f57d0..2b24581604 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -3158,9 +3158,7 @@ namespace ranges {
         }
     }
     // clang-format on
-} // namespace ranges
 
-namespace ranges {
     struct dangling {
         constexpr dangling() noexcept = default;
         template <class... _Args>
@@ -3649,19 +3647,76 @@ _OutCtgIt _Copy_memmove(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
     }
 }
 
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
+    auto _FirstPtr              = _To_address(_First);
+    auto _DestPtr               = _To_address(_Dest);
+    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
+    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
+    const auto _Byte_count      = _Count * sizeof(*_FirstPtr);
+    _CSTD memmove(_Dest_ch, _First_ch, _Byte_count);
+    if constexpr (is_pointer_v<_OutCtgIt>) {
+        return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Byte_count);
+    } else {
+        return _Dest + _Count;
+    }
+}
+
 template <class _It, bool _RequiresMutable = false>
 _INLINE_VAR constexpr bool _Is_vb_iterator = false;
 
 template <class _InIt, class _OutIt>
-_CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
+_CONSTEXPR20 _OutIt _Copy_n_unchecked(_InIt _First, size_t _Count, _OutIt _Dest) {
+    // copy _First + [0, _Count) to _Dest + [0, _Count), returning _Dest + _Count
+    // note: has callers outside the copy family
+    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _Copy_memmove_n(_First, _Count, _Dest);
+        }
+    }
+
+    for (; _Count != 0; ++_Dest, (void) ++_First, --_Count) {
+        *_Dest = *_First;
+    }
+
+    return _Dest;
+}
+
+template <class _InIt, class _Sent, class _OutIt>
+using _Sent_copy_cat = conditional_t<
+#ifdef __cpp_lib_concepts
+    is_same_v<_Sent, _InIt> || sized_sentinel_for<_Sent, _InIt>,
+#else // ^^^ Concepts support / no Concepts vvv
+    is_same_v<_Sent, _InIt>,
+#endif
+    _Iter_copy_cat<_InIt, _OutIt>, _False_trivial_cat>;
+
+template <class _InIt, class _Sent, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
     // copy [_First, _Last) to [_Dest, ...)
     // note: _Copy_unchecked has callers other than the copy family
-    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+    if constexpr (_Sent_copy_cat<_InIt, _Sent, _OutIt>::_Bitcopy_assignable) {
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            return _Copy_memmove(_First, _Last, _Dest);
+#ifdef __cpp_lib_concepts
+            if constexpr (is_same_v<_InIt, _Sent>)
+#else // ^^^ Concepts support / no Concepts vvv
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_InIt, _Sent>);
+#endif // __cpp_lib_concepts
+            {
+                return _Copy_memmove(_First, _Last, _Dest);
+            }
+#ifdef __cpp_lib_concepts
+            else {
+                _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Sent, _InIt>);
+                return _Copy_memmove_n(_First, static_cast<size_t>(_Last - _First), _Dest);
+            }
+#endif // __cpp_lib_concepts
         }
     }
 
@@ -3714,6 +3769,56 @@ namespace ranges {
         }
     };
 
+    // clang-format off
+    template <forward_iterator _Wrapped, class _Se>
+        requires sentinel_for<remove_cvref_t<_Se>, _Wrapped>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(const _Unwrapped_t<_Wrapped>& _UFirst, _Se&& _Last) {
+        // clang-format on
+        // find the iterator in [_UFirst, _Get_unwrapped(_Last)) which equals _Get_unwrapped(_Last) [possibly O(N)]
+        auto _ULast = _Get_unwrapped(_STD forward<_Se>(_Last));
+        if constexpr (is_same_v<remove_cvref_t<_Se>, _Wrapped>) {
+            return _ULast;
+        } else if constexpr (sized_sentinel_for<remove_cvref_t<_Se>, _Wrapped>) {
+            return _RANGES next(_UFirst, _ULast - _UFirst);
+        } else {
+            return _RANGES next(_UFirst, _STD move(_ULast));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        if constexpr (common_range<_Rng>) {
+            if constexpr (same_as<_Unwrapped_t<_RANGES iterator_t<_Rng>>, decltype(_Uend(_Range))>) {
+                return _Uend(_Range);
+            } else {
+                return _Get_unwrapped(_RANGES end(_Range));
+            }
+        } else if constexpr (sized_range<_Rng>) {
+            return _RANGES next(_Ubegin(_Range), _RANGES distance(_Range));
+        } else {
+            return _RANGES next(_Ubegin(_Range), _Uend(_Range));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range, const _Unwrapped_t<iterator_t<_Rng>>& _Mid) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        // Pre: [ranges::begin(_Range), _Mid) and [_Mid, ranges::end(_Range)) denote ranges
+        if constexpr (common_range<_Rng>) {
+            return _Uend(_Range);
+        } else if constexpr (sized_range<_Rng>) {
+            const auto _Dist = _RANGES distance(_Range);
+            if constexpr (sized_sentinel_for<_Unwrapped_t<iterator_t<_Rng>>, _Unwrapped_t<iterator_t<_Rng>>>) {
+                return _RANGES next(_Mid, _Dist - (_Mid - _Ubegin(_Range)));
+            } else {
+                return _RANGES next(_Ubegin(_Range), _Dist);
+            }
+        } else {
+            return _RANGES next(_Mid, _Uend(_Range));
+        }
+    }
+
 #if _HAS_CXX23
     template <class _Out, class _Ty>
     struct out_value_result {
@@ -3740,11 +3845,18 @@ namespace ranges {
         requires indirectly_copyable<_It, _Out>
     _NODISCARD constexpr copy_result<_It, _Out> _Copy_unchecked(_It _First, _Se _Last, _Out _Result) {
         // clang-format on
-        if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_assignable && sized_sentinel_for<_Se, _It>) {
+        if constexpr (_Sent_copy_cat<_It, _Se, _Out>::_Bitcopy_assignable) {
             if (!_STD is_constant_evaluated()) {
-                auto _Final = _RANGES next(_First, _STD move(_Last));
-                _Result     = _Copy_memmove(_STD move(_First), _Final, _STD move(_Result));
-                return {_STD move(_Final), _STD move(_Result)};
+                if constexpr (is_same_v<_It, _Se>) {
+                    _Result = _Copy_memmove(_STD move(_First), _Last, _STD move(_Result));
+                    return {_STD move(_Last), _STD move(_Result)};
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Se, _It>);
+                    auto _Count = static_cast<size_t>(_Last - _First);
+                    _Result     = _Copy_memmove_n(_First, _Count, _STD move(_Result));
+                    _First += _Count;
+                    return {_STD move(_First), _STD move(_Result)};
+                }
             }
         }
 
@@ -3798,7 +3910,7 @@ _CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
             if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
             {
-                _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
+                _UDest = _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _UDest);
                 _Seek_wrapped(_Dest, _UDest);
                 return _Dest;
             }
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 392bfba6a1..c00a1fd27f 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -294,6 +294,7 @@
 // P1072R10 basic_string::resize_and_overwrite
 // P1132R7 out_ptr(), inout_ptr()
 // P1147R1 Printing volatile Pointers
+// P1206R7 Conversions From Ranges To Containers
 // P1272R4 byteswap()
 // P1328R1 constexpr type_info::operator==()
 // P1413R3 Deprecate aligned_storage And aligned_union
@@ -1450,7 +1451,8 @@
 #define __cpp_lib_constexpr_typeinfo                202106L
 
 #ifdef __cpp_lib_concepts
-#define __cpp_lib_expected 202202L
+#define __cpp_lib_containers_ranges 202202L
+#define __cpp_lib_expected          202202L
 #endif // __cpp_lib_concepts
 
 #define __cpp_lib_invoke_r           202106L
@@ -1465,6 +1467,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
 #endif // __cpp_lib_concepts
 
 #define __cpp_lib_spanstream                  202106L
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 80bd87fb66..8c967ad2f6 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -468,6 +468,53 @@ tests\P1135R6_latch
 tests\P1135R6_semaphore
 tests\P1147R1_printing_volatile_pointers
 tests\P1165R1_consistently_propagating_stateful_allocators
+tests\P1206R7_deque_append_range
+tests\P1206R7_deque_assign_range
+tests\P1206R7_deque_from_range
+tests\P1206R7_deque_insert_range
+tests\P1206R7_deque_prepend_range
+tests\P1206R7_forward_list_assign_range
+tests\P1206R7_forward_list_from_range
+tests\P1206R7_forward_list_insert_range
+tests\P1206R7_forward_list_prepend_range
+tests\P1206R7_from_range
+tests\P1206R7_list_append_range
+tests\P1206R7_list_assign_range
+tests\P1206R7_list_from_range
+tests\P1206R7_list_insert_range
+tests\P1206R7_list_prepend_range
+tests\P1206R7_map_from_range
+tests\P1206R7_map_insert_range
+tests\P1206R7_multimap_from_range
+tests\P1206R7_multimap_insert_range
+tests\P1206R7_multiset_from_range
+tests\P1206R7_multiset_insert_range
+tests\P1206R7_priority_queue_from_range
+tests\P1206R7_priority_queue_push_range
+tests\P1206R7_queue_from_range
+tests\P1206R7_queue_push_range
+tests\P1206R7_ranges_to
+tests\P1206R7_set_from_range
+tests\P1206R7_set_insert_range
+tests\P1206R7_stack_from_range
+tests\P1206R7_stack_push_range
+tests\P1206R7_string_append_range
+tests\P1206R7_string_assign_range
+tests\P1206R7_string_from_range
+tests\P1206R7_string_insert_range
+tests\P1206R7_string_replace_with_range
+tests\P1206R7_unordered_map_from_range
+tests\P1206R7_unordered_map_insert_range
+tests\P1206R7_unordered_multimap_from_range
+tests\P1206R7_unordered_multimap_insert_range
+tests\P1206R7_unordered_multiset_from_range
+tests\P1206R7_unordered_multiset_insert_range
+tests\P1206R7_unordered_set_from_range
+tests\P1206R7_unordered_set_insert_range
+tests\P1206R7_vector_append_range
+tests\P1206R7_vector_assign_range
+tests\P1206R7_vector_from_range
+tests\P1206R7_vector_insert_range
 tests\P1208R6_source_location
 tests\P1272R4_byteswap
 tests\P1423R3_char8_t_remediation
diff --git a/tests/std/tests/P0433R2_deduction_guides/test.cpp b/tests/std/tests/P0433R2_deduction_guides/test.cpp
index 37cd60f656..a71c1696cd 100644
--- a/tests/std/tests/P0433R2_deduction_guides/test.cpp
+++ b/tests/std/tests/P0433R2_deduction_guides/test.cpp
@@ -418,6 +418,14 @@ void test_basic_string() {
     static_assert(is_same_v<decltype(str16), wstring>);
     static_assert(is_same_v<decltype(str17), basic_string<wchar_t, char_traits<wchar_t>, MyAlloc<wchar_t>>>);
     static_assert(is_same_v<decltype(str18), basic_string<wchar_t, char_traits<wchar_t>, MyAlloc<wchar_t>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    basic_string str19(from_range, first);
+    basic_string str20(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(str19), wstring>);
+    static_assert(is_same_v<decltype(str20), basic_string<wchar_t, char_traits<wchar_t>, MyAlloc<wchar_t>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 void test_basic_string_view() {
@@ -476,6 +484,14 @@ void test_sequence_container() {
     static_assert(is_same_v<decltype(c5), Sequence<long>>);
     static_assert(is_same_v<decltype(c6), Sequence<long, MyAlloc<long>>>);
     static_assert(is_same_v<decltype(c7), Sequence<long, MyAlloc<long>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    Sequence c8(from_range, first);
+    Sequence c9(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(c8), Sequence<long>>);
+    static_assert(is_same_v<decltype(c9), Sequence<long, MyAlloc<long>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 void test_vector_bool() {
@@ -499,6 +515,14 @@ void test_vector_bool() {
     static_assert(is_same_v<decltype(vb5), vector<bool>>);
     static_assert(is_same_v<decltype(vb6), vector<bool, MyAlloc<bool>>>);
     static_assert(is_same_v<decltype(vb7), vector<bool, MyAlloc<bool>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    vector vb8(from_range, first);
+    vector vb9(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(vb8), vector<bool>>);
+    static_assert(is_same_v<decltype(vb9), vector<bool, MyAlloc<bool>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 template <template <typename K, typename V, typename C = less<K>, typename A = allocator<pair<const K, V>>> typename M>
@@ -534,11 +558,22 @@ void test_map_or_multimap() {
     static_assert(is_same_v<decltype(m11), M<long, char, MyGreater>>);
     static_assert(is_same_v<decltype(m12), M<long, char, MyGreater, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(m13), M<long, char, less<long>, MyAlloc<CPurr>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    M m14(from_range, first);
+    M m15(from_range, first, gt);
+    M m16(from_range, first, gt, myal);
+    M m17(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(m14), M<long, char>>);
+    static_assert(is_same_v<decltype(m15), M<long, char, MyGreater>>);
+    static_assert(is_same_v<decltype(m16), M<long, char, MyGreater, MyAlloc<CPurr>>>);
+    static_assert(is_same_v<decltype(m17), M<long, char, less<long>, MyAlloc<CPurr>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 template <template <typename K, typename C = less<K>, typename A = allocator<K>> typename S>
 void test_set_or_multiset() {
-
     const long first[] = {10L, 20L, 30L};
     const auto last    = end(first);
     MyGreater gt{};
@@ -564,6 +599,18 @@ void test_set_or_multiset() {
     static_assert(is_same_v<decltype(s7), S<long, less<long>, MyAlloc<long>>>);
     static_assert(is_same_v<decltype(s8), S<long, less<long>, MyAlloc<long>>>);
     static_assert(is_same_v<decltype(s9), S<long, less<long>, MyAlloc<long>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    S s10(from_range, first);
+    S s11(from_range, first, gt);
+    S s12(from_range, first, gt, myal);
+    S s13(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(s10), S<long>>);
+    static_assert(is_same_v<decltype(s11), S<long, MyGreater>>);
+    static_assert(is_same_v<decltype(s12), S<long, MyGreater, MyAlloc<long>>>);
+    static_assert(is_same_v<decltype(s13), S<long, less<long>, MyAlloc<long>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 template <template <typename K, typename V, typename H = hash<K>, typename P = equal_to<K>,
@@ -616,11 +663,30 @@ void test_unordered_map_or_unordered_multimap() {
     static_assert(is_same_v<decltype(um23), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(um24), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(um25), UM<long, char, MyHash, equal_to<long>, MyAlloc<CPurr>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    UM um26(from_range, first);
+    UM um27(from_range, first, 7);
+    UM um28(from_range, first, 7, hf);
+    UM um29(from_range, first, 7, hf, eq);
+    UM um30(from_range, first, 7, hf, eq, myal);
+    UM um31(from_range, first, myal);
+    UM um32(from_range, first, 7, myal);
+    UM um33(from_range, first, 7, hf, myal);
+
+    static_assert(is_same_v<decltype(um26), UM<long, char>>);
+    static_assert(is_same_v<decltype(um27), UM<long, char>>);
+    static_assert(is_same_v<decltype(um28), UM<long, char, MyHash>>);
+    static_assert(is_same_v<decltype(um29), UM<long, char, MyHash, MyEqual>>);
+    static_assert(is_same_v<decltype(um30), UM<long, char, MyHash, MyEqual, MyAlloc<CPurr>>>);
+    static_assert(is_same_v<decltype(um31), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
+    static_assert(is_same_v<decltype(um32), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
+    static_assert(is_same_v<decltype(um33), UM<long, char, MyHash, equal_to<long>, MyAlloc<CPurr>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 template <template <typename K, typename H = hash<K>, typename P = equal_to<K>, typename A = allocator<K>> typename US>
 void test_unordered_set_or_unordered_multiset() {
-
     const long first[] = {10L, 20L, 30L};
     const auto last    = end(first);
     MyHash hf{};
@@ -659,6 +725,24 @@ void test_unordered_set_or_unordered_multiset() {
     static_assert(is_same_v<decltype(us13), US<long, hash<long>, equal_to<long>, MyAlloc<long>>>);
     static_assert(is_same_v<decltype(us14), US<long, MyHash, equal_to<long>, MyAlloc<long>>>);
     static_assert(is_same_v<decltype(us15), US<long, MyHash, MyEqual, MyAlloc<long>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    US us16(from_range, first);
+    US us17(from_range, first, 7);
+    US us18(from_range, first, 7, hf);
+    US us19(from_range, first, 7, hf, eq);
+    US us20(from_range, first, 7, hf, eq, myal);
+    US us21(from_range, first, 7, myal);
+    US us22(from_range, first, 7, hf, myal);
+
+    static_assert(is_same_v<decltype(us16), US<long>>);
+    static_assert(is_same_v<decltype(us17), US<long>>);
+    static_assert(is_same_v<decltype(us18), US<long, MyHash>>);
+    static_assert(is_same_v<decltype(us19), US<long, MyHash, MyEqual>>);
+    static_assert(is_same_v<decltype(us20), US<long, MyHash, MyEqual, MyAlloc<long>>>);
+    static_assert(is_same_v<decltype(us21), US<long, hash<long>, equal_to<long>, MyAlloc<long>>>);
+    static_assert(is_same_v<decltype(us22), US<long, MyHash, equal_to<long>, MyAlloc<long>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 void test_queue_and_stack() {
@@ -673,6 +757,25 @@ void test_queue_and_stack() {
     static_assert(is_same_v<decltype(q2), queue<long, list<long, MyAlloc<long>>>>);
     static_assert(is_same_v<decltype(q3), queue<long, list<long, MyAlloc<long>>>>);
 
+#if _HAS_CXX23
+    const long first[] = {10L, 20L, 30L};
+    const auto last    = end(first);
+
+    queue q4(first, last);
+    queue q5(first, last, myal);
+
+    static_assert(is_same_v<decltype(q4), queue<long>>);
+    static_assert(is_same_v<decltype(q5), queue<long, deque<long, MyAlloc<long>>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    queue q6(from_range, first);
+    queue q7(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(q6), queue<long>>);
+    static_assert(is_same_v<decltype(q7), queue<long, deque<long, MyAlloc<long>>>>);
+#endif // __cpp_lib_containers_ranges
+#endif // _HAS_CXX23
+
     stack s1(lst);
     stack s2(lst, myal);
     stack s3(s2);
@@ -680,6 +783,22 @@ void test_queue_and_stack() {
     static_assert(is_same_v<decltype(s1), stack<long, list<long, MyAlloc<long>>>>);
     static_assert(is_same_v<decltype(s2), stack<long, list<long, MyAlloc<long>>>>);
     static_assert(is_same_v<decltype(s3), stack<long, list<long, MyAlloc<long>>>>);
+
+#if _HAS_CXX23
+    stack s4(first, last);
+    stack s5(first, last, myal);
+
+    static_assert(is_same_v<decltype(s4), stack<long>>);
+    static_assert(is_same_v<decltype(s5), stack<long, deque<long, MyAlloc<long>>>>);
+
+#ifdef __cpp_lib_containers_ranges
+    stack s6(from_range, first);
+    stack s7(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(s6), stack<long>>);
+    static_assert(is_same_v<decltype(s7), stack<long, deque<long, MyAlloc<long>>>>);
+#endif // __cpp_lib_containers_ranges
+#endif // _HAS_CXX23
 }
 
 void test_priority_queue() {
@@ -694,14 +813,32 @@ void test_priority_queue() {
     priority_queue pq3(first, last);
     priority_queue pq4(first, last, gt);
     priority_queue pq5(first, last, gt, deq);
-    priority_queue pq6(pq5);
+    priority_queue pq6(first, last, myal);
+    priority_queue pq7(first, last, gt, myal);
+    priority_queue pq8(first, last, gt, deq, myal);
+    priority_queue pq9(pq5);
 
     static_assert(is_same_v<decltype(pq1), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
     static_assert(is_same_v<decltype(pq2), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
     static_assert(is_same_v<decltype(pq3), priority_queue<long>>);
     static_assert(is_same_v<decltype(pq4), priority_queue<long, vector<long>, MyGreater>>);
     static_assert(is_same_v<decltype(pq5), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
-    static_assert(is_same_v<decltype(pq6), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
+    static_assert(is_same_v<decltype(pq6), priority_queue<long, vector<long, MyAlloc<long>>>>);
+    static_assert(is_same_v<decltype(pq7), priority_queue<long, vector<long, MyAlloc<long>>, MyGreater>>);
+    static_assert(is_same_v<decltype(pq8), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
+    static_assert(is_same_v<decltype(pq9), priority_queue<long, deque<long, MyAlloc<long>>, MyGreater>>);
+
+#ifdef __cpp_lib_containers_ranges
+    priority_queue pq10(from_range, first);
+    priority_queue pq11(from_range, first, gt);
+    priority_queue pq12(from_range, first, gt, myal);
+    priority_queue pq13(from_range, first, myal);
+
+    static_assert(is_same_v<decltype(pq10), priority_queue<long>>);
+    static_assert(is_same_v<decltype(pq11), priority_queue<long, vector<long>, MyGreater>>);
+    static_assert(is_same_v<decltype(pq12), priority_queue<long, vector<long, MyAlloc<long>>, MyGreater>>);
+    static_assert(is_same_v<decltype(pq13), priority_queue<long, vector<long, MyAlloc<long>>>>);
+#endif // __cpp_lib_containers_ranges
 }
 
 void test_iterator_adaptors() {
diff --git a/tests/std/tests/P0784R7_library_machinery/test.cpp b/tests/std/tests/P0784R7_library_machinery/test.cpp
index 4fe86b10e0..e341b4b39d 100644
--- a/tests/std/tests/P0784R7_library_machinery/test.cpp
+++ b/tests/std/tests/P0784R7_library_machinery/test.cpp
@@ -64,6 +64,16 @@ constexpr bool test() {
         assert(equal(begin(expected_copy), end(expected_copy), begin(output), end(output)));
     }
 
+    { // _Copy_n_unchecked
+        int_wrapper_copy input[]   = {1, 2, 3, 4};
+        int_wrapper_copy output[4] = {5, 6, 7, 8};
+
+        const auto result = _Copy_n_unchecked(begin(input), size(input), begin(output));
+        static_assert(is_same_v<remove_const_t<decltype(result)>, int_wrapper_copy*>);
+        assert(result == end(output));
+        assert(equal(begin(expected_copy), end(expected_copy), begin(output), end(output)));
+    }
+
     { // _Copy_backward_unchecked
         int_wrapper_copy input[]   = {1, 2, 3, 4};
         int_wrapper_copy output[4] = {5, 6, 7, 8};
diff --git a/tests/std/tests/P1206R7_deque_append_range/env.lst b/tests/std/tests/P1206R7_deque_append_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_append_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_deque_append_range/test.cpp b/tests/std/tests/P1206R7_deque_append_range/test.cpp
new file mode 100644
index 0000000000..c9a2a261c5
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_append_range/test.cpp
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+void test_deque(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    deque<int> d(presize, -1);
+
+    d.append_range(forward<Rng>(rng));
+    const auto count = static_cast<ptrdiff_t>(presize);
+    assert(ranges::count(d | views::take(count), -1) == count);
+    assert(ranges::equal(d | views::drop(count), expected));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_deque(const int (&expected)[N]) {
+    test_deque(0, Rng{expected}, expected);
+    test_deque(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_deque<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_deque<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_deque<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_deque<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_deque<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_deque(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_deque(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_deque_assign_range/env.lst b/tests/std/tests/P1206R7_deque_assign_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_assign_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_deque_assign_range/test.cpp b/tests/std/tests/P1206R7_deque_assign_range/test.cpp
new file mode 100644
index 0000000000..3889134bdf
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_assign_range/test.cpp
@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_deque(const size_t presize, Rng&& rng, Expected&& expected) {
+    deque<int> d(presize, -1);
+    d.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(d, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_deque(0, R{some_ints}, some_ints);
+        test_deque(5, R{some_ints}, some_ints);
+        test_deque(11, R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_deque(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_deque(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_deque(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_deque(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_deque(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_deque_from_range/env.lst b/tests/std/tests/P1206R7_deque_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_deque_from_range/test.cpp b/tests/std/tests/P1206R7_deque_from_range/test.cpp
new file mode 100644
index 0000000000..adf438beeb
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_from_range/test.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_deque(Rng&& rng, Expected&& expected) {
+    deque<int> d{from_range, forward<Rng>(rng)};
+    assert(ranges::equal(d, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_deque(R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_deque(s, some_ints);
+    }
+
+    { // move-only views
+        test_deque(move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_deque(move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_deque(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_deque(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_deque(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_deque(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_deque(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    }
+
+    // Validate non-views
+    test_deque(some_ints, some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_deque(vec, some_ints);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_deque(lst, some_ints);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_deque_insert_range/env.lst b/tests/std/tests/P1206R7_deque_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_deque_insert_range/test.cpp b/tests/std/tests/P1206R7_deque_insert_range/test.cpp
new file mode 100644
index 0000000000..8b9bd8eb61
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_insert_range/test.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_deque(const size_t presize, Rng&& rng, Expected&& expected) {
+    deque<int> d(presize, -1);
+    const same_as<deque<int>::iterator> auto result = d.insert_range(d.begin() + (presize != 0), forward<Rng>(rng));
+    assert(result == d.begin() + (presize != 0));
+    assert(ranges::equal(d, expected));
+}
+
+static constexpr int some_ints[]    = {0, 1, 2, 3, 4, 5, 6, 7};
+static constexpr int short_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1}; // result of inserting some_ints at offset 1 in a sequence of 5 -1s
+static constexpr int long_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // ditto, in a sequence of 11 -1s
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_deque(0, R{some_ints}, some_ints);
+        test_deque(5, R{some_ints}, short_result);
+        test_deque(11, R{some_ints}, long_result);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_deque(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_deque(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_deque(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_deque(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_deque(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_deque(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_deque_prepend_range/env.lst b/tests/std/tests/P1206R7_deque_prepend_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_prepend_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_deque_prepend_range/test.cpp b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
new file mode 100644
index 0000000000..ac3f75df5a
--- /dev/null
+++ b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+void test_deque(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    deque<int> d(presize, -1);
+
+    d.prepend_range(forward<Rng>(rng));
+    assert(ranges::equal(d | views::take(ptrdiff_t{N}), expected));
+    assert(ranges::count(d | views::drop(ptrdiff_t{N}), -1) == static_cast<ptrdiff_t>(presize));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_deque(const int (&expected)[N]) {
+    test_deque(0, Rng{expected}, expected);
+    test_deque(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_deque<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_deque<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_deque<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_deque<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_deque<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_deque<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_deque(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_deque(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_deque(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_forward_list_assign_range/env.lst b/tests/std/tests/P1206R7_forward_list_assign_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_assign_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_forward_list_assign_range/test.cpp b/tests/std/tests/P1206R7_forward_list_assign_range/test.cpp
new file mode 100644
index 0000000000..df096b67af
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_assign_range/test.cpp
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_flist(const size_t presize, Rng&& rng, Expected&& expected) {
+    forward_list<int> fl(presize, -1);
+    fl.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(fl, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_flist(0, R{some_ints}, some_ints);
+        test_flist(5, R{some_ints}, some_ints);
+        test_flist(11, R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_flist(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_flist(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_flist(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_flist(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_flist(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_flist(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_flist(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_forward_list_from_range/env.lst b/tests/std/tests/P1206R7_forward_list_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_forward_list_from_range/test.cpp b/tests/std/tests/P1206R7_forward_list_from_range/test.cpp
new file mode 100644
index 0000000000..4dded78cba
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_from_range/test.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_flist(Rng&& rng, Expected&& expected) {
+    forward_list<int> fl{from_range, forward<Rng>(rng)};
+    static_assert(same_as<decltype(fl), forward_list<int>>);
+    assert(ranges::equal(fl, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_flist(R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_flist(s, some_ints);
+    }
+
+    { // move-only views
+        test_flist(move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_flist(move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_flist(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_flist(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_flist(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_flist(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_flist(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    }
+
+    // Validate non-views
+    test_flist(some_ints, some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_flist(vec, some_ints);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_flist(lst, some_ints);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_forward_list_insert_range/env.lst b/tests/std/tests/P1206R7_forward_list_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp b/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
new file mode 100644
index 0000000000..c9c7d795a5
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_flist(const size_t presize, Rng&& rng, Expected&& expected) {
+    forward_list<int> fl(presize, -1);
+    const same_as<forward_list<int>::iterator> auto result =
+        fl.insert_range_after(presize ? fl.begin() : fl.before_begin(), forward<Rng>(rng));
+    assert(result == ranges::next(presize ? fl.begin() : fl.before_begin(), 8));
+    assert(ranges::equal(fl, expected));
+}
+
+static constexpr int some_ints[]    = {0, 1, 2, 3, 4, 5, 6, 7};
+static constexpr int short_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1}; // result of inserting some_ints at offset 1 in a sequence of 5 -1s
+static constexpr int long_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // ditto, in a sequence of 11 -1s
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_flist(0, R{some_ints}, some_ints);
+        test_flist(5, R{some_ints}, short_result);
+        test_flist(11, R{some_ints}, long_result);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_flist(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_flist(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_flist(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_flist(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_flist(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_flist(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_flist(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_flist(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_forward_list_prepend_range/env.lst b/tests/std/tests/P1206R7_forward_list_prepend_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_prepend_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
new file mode 100644
index 0000000000..2085bc8998
--- /dev/null
+++ b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+void test_flist(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    forward_list<int> fl(presize, -1);
+
+    fl.prepend_range(forward<Rng>(rng));
+    assert(ranges::equal(fl | views::take(ptrdiff_t{N}), expected));
+    assert(ranges::count(fl | views::drop(ptrdiff_t{N}), -1) == static_cast<ptrdiff_t>(presize));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_flist(const int (&expected)[N]) {
+    test_flist(0, Rng{expected}, expected);
+    test_flist(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_flist<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_flist<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_flist<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_flist<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_flist<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_flist<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_flist<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_flist<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_flist<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_flist(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_flist(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_flist(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_from_range/env.lst b/tests/std/tests/P1206R7_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_from_range/test.compile.pass.cpp b/tests/std/tests/P1206R7_from_range/test.compile.pass.cpp
new file mode 100644
index 0000000000..7c7b91a457
--- /dev/null
+++ b/tests/std/tests/P1206R7_from_range/test.compile.pass.cpp
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <ranges>
+#include <type_traits>
+
+using namespace std;
+
+int main() {} // COMPILE-ONLY
+
+static_assert(same_as<decltype(from_range), const from_range_t>);
+static_assert(semiregular<from_range_t>);
+
+void helper(auto);
+
+template <class T>
+concept can_implicitly_construct = requires {
+    helper<T>({});
+};
+
+static_assert(!can_implicitly_construct<from_range_t>);
diff --git a/tests/std/tests/P1206R7_list_append_range/env.lst b/tests/std/tests/P1206R7_list_append_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_append_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_list_append_range/test.cpp b/tests/std/tests/P1206R7_list_append_range/test.cpp
new file mode 100644
index 0000000000..afaa32b48b
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_append_range/test.cpp
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+void test_list(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    list<int> lst(presize, -1);
+
+    lst.append_range(forward<Rng>(rng));
+    const auto count = static_cast<ptrdiff_t>(presize);
+    assert(ranges::count(lst | views::take(count), -1) == count);
+    assert(ranges::equal(lst | views::drop(count), expected));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_list(const int (&expected)[N]) {
+    test_list(0, Rng{expected}, expected);
+    test_list(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_list<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_list<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_list<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_list<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_list<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_list(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_list(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_list_assign_range/env.lst b/tests/std/tests/P1206R7_list_assign_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_assign_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_list_assign_range/test.cpp b/tests/std/tests/P1206R7_list_assign_range/test.cpp
new file mode 100644
index 0000000000..9052da6335
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_assign_range/test.cpp
@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_list(const size_t presize, Rng&& rng, Expected&& expected) {
+    list<int> lst(presize, -1);
+    lst.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(lst, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_list(0, R{some_ints}, some_ints);
+        test_list(5, R{some_ints}, some_ints);
+        test_list(11, R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_list(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_list(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_list(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_list(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_list(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_list_from_range/env.lst b/tests/std/tests/P1206R7_list_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_list_from_range/test.cpp b/tests/std/tests/P1206R7_list_from_range/test.cpp
new file mode 100644
index 0000000000..0e1de022ec
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_from_range/test.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_list(Rng&& rng, Expected&& expected) {
+    list<int> lst(from_range, forward<Rng>(rng));
+    assert(ranges::equal(lst, expected));
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_list(R{some_ints}, some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_list(s, some_ints);
+    }
+
+    { // move-only views
+        test_list(move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_list(move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_list(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_list(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_list(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_list(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_list(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    }
+
+    // Validate non-views
+    test_list(some_ints, some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_list(vec, some_ints);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_list(lst, some_ints);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_list_insert_range/env.lst b/tests/std/tests/P1206R7_list_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_list_insert_range/test.cpp b/tests/std/tests/P1206R7_list_insert_range/test.cpp
new file mode 100644
index 0000000000..21d7264a70
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_insert_range/test.cpp
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+void test_list(const size_t presize, Rng&& rng, Expected&& expected) {
+    list<int> lst(presize, -1);
+    const same_as<list<int>::iterator> auto result =
+        lst.insert_range(ranges::next(lst.begin(), presize != 0), forward<Rng>(rng));
+    assert(result == ranges::next(lst.begin(), presize != 0));
+    assert(ranges::equal(lst, expected));
+}
+
+static constexpr int some_ints[]    = {0, 1, 2, 3, 4, 5, 6, 7};
+static constexpr int short_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1}; // result of inserting some_ints at offset 1 in a sequence of 5 -1s
+static constexpr int long_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // ditto, in a sequence of 11 -1s
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_list(0, R{some_ints}, some_ints);
+        test_list(5, R{some_ints}, short_result);
+        test_list(11, R{some_ints}, long_result);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_list(0, s, some_ints);
+}
+
+void test_move_only_views() {
+    test_list(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_list(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_list(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_list(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+}
+
+void test_c_array() {
+    test_list(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_list_prepend_range/env.lst b/tests/std/tests/P1206R7_list_prepend_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_prepend_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
new file mode 100644
index 0000000000..e1261974d2
--- /dev/null
+++ b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+void test_list(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    list<int> lst(presize, -1);
+
+    lst.prepend_range(forward<Rng>(rng));
+    assert(ranges::equal(lst | views::take(ptrdiff_t{N}), expected));
+    assert(ranges::count(lst | views::drop(ptrdiff_t{N}), -1) == static_cast<ptrdiff_t>(presize));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_list(const int (&expected)[N]) {
+    test_list(0, Rng{expected}, expected);
+    test_list(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_list<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_list<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_list<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_list<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_list<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_list<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_list(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_list(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_list(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_map_from_range/env.lst b/tests/std/tests/P1206R7_map_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_map_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_map_from_range/test.cpp b/tests/std/tests/P1206R7_map_from_range/test.cpp
new file mode 100644
index 0000000000..5d06652428
--- /dev/null
+++ b/tests/std/tests/P1206R7_map_from_range/test.cpp
@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <map>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_map(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        map<int, int> m{from_range, forward<Rng>(rng)};
+        assert(ranges::equal(m, expected, equal_to<pair<int, int>>{}));
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+
+struct map_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_map(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_map(s);
+}
+
+void test_move_only_views() {
+    test_map(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_map(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_map(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_map(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_map(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_map(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<map_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_map_insert_range/env.lst b/tests/std/tests/P1206R7_map_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_map_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_map_insert_range/test.cpp b/tests/std/tests/P1206R7_map_insert_range/test.cpp
new file mode 100644
index 0000000000..947a2ab180
--- /dev/null
+++ b/tests/std/tests/P1206R7_map_insert_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <map>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_map(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        map<int, int> m;
+        m.insert_range(forward<Rng>(rng));
+        assert(ranges::equal(m, expected, equal_to<pair<int, int>>{}));
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+
+struct map_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_map(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_map(s);
+}
+
+void test_move_only_views() {
+    test_map(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_map(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_map(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_map(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_map(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_map(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_map(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<map_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_multimap_from_range/env.lst b/tests/std/tests/P1206R7_multimap_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_multimap_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_multimap_from_range/test.cpp b/tests/std/tests/P1206R7_multimap_from_range/test.cpp
new file mode 100644
index 0000000000..8172c81203
--- /dev/null
+++ b/tests/std/tests/P1206R7_multimap_from_range/test.cpp
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <map>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 16}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_multimap(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        multimap<int, int> m{from_range, forward<Rng>(rng)};
+        assert(ranges::equal(m, expected, equal_to<pair<int, int>>{}));
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 16}, {5, 15}, {6, 14}, {4, 16}, {7, 13}, {1, 19}};
+
+struct multimap_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_multimap(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_multimap(s);
+}
+
+void test_move_only_views() {
+    test_multimap(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_multimap(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_multimap(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_multimap(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_multimap(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_multimap(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<multimap_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_multimap_insert_range/env.lst b/tests/std/tests/P1206R7_multimap_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_multimap_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_multimap_insert_range/test.cpp b/tests/std/tests/P1206R7_multimap_insert_range/test.cpp
new file mode 100644
index 0000000000..68b19fea60
--- /dev/null
+++ b/tests/std/tests/P1206R7_multimap_insert_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <map>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_multimap(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        multimap<int, int> m;
+        m.insert_range(forward<Rng>(rng));
+        assert(ranges::equal(m, expected, equal_to<pair<int, int>>{}));
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+
+struct multimap_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_multimap(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_multimap(s);
+}
+
+void test_move_only_views() {
+    test_multimap(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_multimap(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_multimap(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_multimap(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_multimap(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_multimap(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_multimap(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<multimap_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_multiset_from_range/env.lst b/tests/std/tests/P1206R7_multiset_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_multiset_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_multiset_from_range/test.cpp b/tests/std/tests/P1206R7_multiset_from_range/test.cpp
new file mode 100644
index 0000000000..3a868ee5c0
--- /dev/null
+++ b/tests/std/tests/P1206R7_multiset_from_range/test.cpp
@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <set>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 4, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_multiset(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        multiset<int> m{from_range, forward<Rng>(rng)};
+        assert(ranges::equal(m, expected));
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
+
+struct multiset_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_multiset(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_multiset(s);
+}
+
+void test_move_only_views() {
+    test_multiset(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_multiset(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_multiset(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_multiset(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_multiset(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_multiset(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<multiset_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_multiset_insert_range/env.lst b/tests/std/tests/P1206R7_multiset_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_multiset_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_multiset_insert_range/test.cpp b/tests/std/tests/P1206R7_multiset_insert_range/test.cpp
new file mode 100644
index 0000000000..24ceebe746
--- /dev/null
+++ b/tests/std/tests/P1206R7_multiset_insert_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <set>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 4, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_multiset(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        multiset<int> m;
+        m.insert_range(forward<Rng>(rng));
+        assert(ranges::equal(m, expected));
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
+
+struct multiset_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_multiset(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_multiset(s);
+}
+
+void test_move_only_views() {
+    test_multiset(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_multiset(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_multiset(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_multiset(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_multiset(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_multiset(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_multiset(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<multiset_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_priority_queue_from_range/env.lst b/tests/std/tests/P1206R7_priority_queue_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_priority_queue_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
new file mode 100644
index 0000000000..44aff1e9cb
--- /dev/null
+++ b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <new>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
+
+template <ranges::input_range R, class... Args>
+void test_priority_queue(R&& r, Args&&... args) {
+    adaptor_adaptor<priority_queue<int>> s{from_range, r, forward<Args>(args)...};
+    assert(ranges::is_heap(s.get_container()));
+}
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_priority_queue(R{some_ints});
+        test_priority_queue(R{some_ints}, less<int>{});
+        test_priority_queue(R{some_ints}, less<int>{}, allocator<int>{});
+        test_priority_queue(R{some_ints}, allocator<int>{});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_priority_queue(s);
+    }
+
+    { // move-only views
+        test_priority_queue(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+        test_priority_queue(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+        test_priority_queue(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+        test_priority_queue(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+        test_priority_queue(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+        test_priority_queue(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+        test_priority_queue(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+    }
+
+    // Validate non-views
+    test_priority_queue(some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_priority_queue(vec);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_priority_queue(lst);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_priority_queue_push_range/env.lst b/tests/std/tests/P1206R7_priority_queue_push_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_priority_queue_push_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
new file mode 100644
index 0000000000..2ef6c7800f
--- /dev/null
+++ b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <forward_list>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
+
+template <ranges::input_range Rng>
+void test_priority_queue(const size_t presize, Rng&& rng) {
+    adaptor_adaptor<priority_queue<int>> pq{less<int>{}, vector<int>(presize, -1)};
+
+    pq.push_range(forward<Rng>(rng));
+    const auto& container = pq.get_container();
+    assert(ranges::is_heap(container));
+}
+
+template <ranges::input_range Rng>
+void test_priority_queue() {
+    test_priority_queue(0, Rng{some_ints});
+    test_priority_queue(3, Rng{some_ints});
+}
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_priority_queue<R>();
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_priority_queue<span<const int>>();
+}
+
+void test_move_only_view() {
+    test_priority_queue<move_only_view<input_iterator_tag, test::Common::no>>();
+    test_priority_queue<move_only_view<forward_iterator_tag, test::Common::no>>();
+    test_priority_queue<move_only_view<forward_iterator_tag, test::Common::yes>>();
+    test_priority_queue<move_only_view<bidirectional_iterator_tag, test::Common::no>>();
+    test_priority_queue<move_only_view<bidirectional_iterator_tag, test::Common::yes>>();
+    test_priority_queue<move_only_view<random_access_iterator_tag, test::Common::no>>();
+    test_priority_queue<move_only_view<random_access_iterator_tag, test::Common::yes>>();
+}
+
+void test_c_array() {
+    test_priority_queue(0, some_ints);
+    test_priority_queue(3, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_priority_queue(0, vec);
+    test_priority_queue(3, vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(from_range, some_ints);
+    test_priority_queue(0, lst);
+    test_priority_queue(3, lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_queue_from_range/env.lst b/tests/std/tests/P1206R7_queue_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_queue_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_queue_from_range/test.cpp b/tests/std/tests/P1206R7_queue_from_range/test.cpp
new file mode 100644
index 0000000000..ea55cf7faf
--- /dev/null
+++ b/tests/std/tests/P1206R7_queue_from_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <new>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range R, class... Args>
+void test_queue(R&& r, Args&&... args) {
+    adaptor_adaptor<queue<int>> s{from_range, r, forward<Args>(args)...};
+    assert(ranges::equal(s.get_container(), some_ints));
+}
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_queue(R{some_ints});
+        test_queue(R{some_ints}, allocator<int>{});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_queue(s);
+    }
+
+    { // move-only views
+        test_queue(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+        test_queue(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+        test_queue(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+        test_queue(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+        test_queue(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+        test_queue(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+        test_queue(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+    }
+
+    // Validate non-views
+    test_queue(some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_queue(vec);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_queue(lst);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_queue_push_range/env.lst b/tests/std/tests/P1206R7_queue_push_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_queue_push_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_queue_push_range/test.cpp b/tests/std/tests/P1206R7_queue_push_range/test.cpp
new file mode 100644
index 0000000000..5acd02a1b5
--- /dev/null
+++ b/tests/std/tests/P1206R7_queue_push_range/test.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <forward_list>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+template <ranges::input_range Rng, size_t N>
+void test_queue(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    adaptor_adaptor<queue<int>> d{deque<int>(presize, -1)};
+
+    d.push_range(forward<Rng>(rng));
+    const auto count      = static_cast<ptrdiff_t>(presize);
+    const auto& container = d.get_container();
+    assert(ranges::count(container | views::take(count), -1) == count);
+    assert(ranges::equal(container | views::drop(count), expected));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_queue(const int (&expected)[N]) {
+    test_queue(0, Rng{expected}, expected);
+    test_queue(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_queue<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_queue<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_queue<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_queue<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_queue<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_queue<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_queue<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_queue<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_queue<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_queue(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_queue(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_queue(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_ranges_to/env.lst b/tests/std/tests/P1206R7_ranges_to/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_ranges_to/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_ranges_to/test.cpp b/tests/std/tests/P1206R7_ranges_to/test.cpp
new file mode 100644
index 0000000000..2eae7a7014
--- /dev/null
+++ b/tests/std/tests/P1206R7_ranges_to/test.cpp
@@ -0,0 +1,616 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <deque>
+#include <format>
+#include <forward_list>
+#include <iostream>
+#include <list>
+#include <map>
+#include <ranges>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std::literals;
+
+namespace ranges = std::ranges;
+
+template <class T>
+struct myalloc {
+    using value_type = T;
+
+    int state = 42;
+
+    myalloc() = default;
+    constexpr explicit myalloc(int i) noexcept : state{i} {}
+    template <class U>
+    constexpr myalloc(const myalloc<U>& that) noexcept : state{that.state} {}
+
+    [[nodiscard]] constexpr T* allocate(std::size_t n) const {
+        return std::allocator<T>{}.allocate(n);
+    }
+
+    constexpr void deallocate(T* const p, const std::size_t n) const noexcept {
+        std::allocator<T>{}.deallocate(p, n);
+    }
+
+    template <class U>
+    constexpr bool operator==(const myalloc<U>& that) const noexcept {
+        return state == that.state;
+    }
+};
+
+struct sequence_instantiator {
+    template <template <class...> class C>
+    struct deduce_container_impl {
+        template <class... Args>
+        using apply = C<Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::basic_string> {
+        template <class T, class... Args>
+        using apply = std::basic_string<T, std::char_traits<T>, Args...>;
+    };
+
+    template <template <class...> class C, class T, class... Args>
+    using deduce_container = typename deduce_container_impl<C>::template apply<T, Args...>;
+
+    static constexpr auto meow = "meow"sv;
+
+    template <template <class...> class C>
+    static constexpr bool test_copy_move() {
+        const auto c = ranges::to<C<char>>(meow);
+
+        // validate the "direct" construction path with some copies and moves
+        {
+            std::same_as<C<char>> auto c0 = ranges::to<C<char>>(ranges::to<C<char>>(meow));
+            assert(c0 == c);
+        }
+        {
+            std::same_as<C<char>> auto c1 = ranges::to<C<char>>(c);
+            assert(c1 == c);
+        }
+        {
+            std::same_as<C<char>> auto c2 = ranges::to<C>(ranges::to<C<char>>(meow));
+            assert(c2 == c);
+        }
+        {
+            std::same_as<C<char>> auto c3 = ranges::to<C>(c);
+            assert(c3 == c);
+        }
+        {
+            std::same_as<C<char>> auto c4 = ranges::to<C<char>>(meow) | ranges::to<C<char>>();
+            assert(c4 == c);
+        }
+        {
+            std::same_as<C<char>> auto c5 = c | ranges::to<C<char>>();
+            assert(c5 == c);
+        }
+        {
+            std::same_as<C<char>> auto c6 = ranges::to<C<char>>(meow) | ranges::to<C>();
+            assert(c6 == c);
+        }
+        {
+            std::same_as<C<char>> auto c7 = c | ranges::to<C>();
+            assert(c7 == c);
+        }
+
+        return true;
+    }
+
+    template <ranges::input_range R, template <class...> class C>
+    static constexpr bool test_sequence() {
+        // validate from_range construction and deduction guides
+        {
+            std::same_as<C<char>> auto c0 = ranges::to<C<char>>(R{meow});
+            assert(ranges::equal(c0, meow));
+        }
+        {
+            std::same_as<C<char>> auto c1 = ranges::to<C>(R{meow});
+            assert(ranges::equal(c1, meow));
+        }
+        {
+            std::same_as<C<char>> auto c2 = R{meow} | ranges::to<C<char>>();
+            assert(ranges::equal(c2, meow));
+        }
+        {
+            std::same_as<C<char>> auto c3 = R{meow} | ranges::to<C>();
+            assert(ranges::equal(c3, meow));
+        }
+
+        // validate from_range construction and deduction guides with an extra argument
+        using Alloc = myalloc<char>;
+        using T     = deduce_container<C, char, Alloc>;
+
+        {
+            std::same_as<T> auto c4 = ranges::to<T>(R{meow}, Alloc{13});
+            assert(c4.get_allocator().state == 13);
+            assert(ranges::equal(c4, meow));
+        }
+        {
+            std::same_as<T> auto c5 = ranges::to<C>(R{meow}, Alloc{13});
+            assert(c5.get_allocator().state == 13);
+            assert(ranges::equal(c5, meow));
+        }
+        {
+            std::same_as<T> auto c6 = R{meow} | ranges::to<T>(Alloc{13});
+            assert(c6.get_allocator().state == 13);
+            assert(ranges::equal(c6, meow));
+        }
+        {
+            std::same_as<T> auto c7 = R{meow} | ranges::to<C>(Alloc{13});
+            assert(c7.get_allocator().state == 13);
+            assert(ranges::equal(c7, meow));
+        }
+
+        return true;
+    }
+
+    template <ranges::input_range R>
+    static void call() {
+        test_sequence<R, std::basic_string>();
+        test_sequence<R, std::deque>();
+        test_sequence<R, std::forward_list>();
+        test_sequence<R, std::list>();
+        test_sequence<R, std::vector>();
+
+#ifdef __cpp_lib_constexpr_string
+        static_assert(test_sequence<R, std::basic_string>());
+#endif // __cpp_lib_constexpr_string
+#ifdef __cpp_lib_constexpr_vector
+        static_assert(test_sequence<R, std::vector>());
+#endif // __cpp_lib_constexpr_vector
+    }
+};
+
+struct mappish_instantiator {
+    static constexpr std::pair<int, std::string_view> some_pairs[]   = {{0, "0"}, {1, "1a"}, {1, "1b"}, {1, "1c"},
+        {2, "2"}, {3, "3"}, {4, "4"}, {5, "5a"}, {5, "5b"}, {6, "6"}, {7, "7"}};
+    static constexpr std::pair<int, std::string_view> unique_pairs[] = {
+        {0, "0"}, {1, "1a"}, {2, "2"}, {3, "3"}, {4, "4"}, {5, "5a"}, {6, "6"}, {7, "7"}};
+
+    enum class is_multi : bool { no, yes };
+
+    static constexpr auto any_pair_eq = [](auto x, auto y) { return x.first == y.first && x.second == y.second; };
+
+    template <template <class...> class C>
+    struct deduce_container_impl; // not defined
+    template <>
+    struct deduce_container_impl<std::map> {
+        template <class Key, class Val, class... Args>
+        using apply = std::map<Key, Val, std::less<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::multimap> {
+        template <class Key, class Val, class... Args>
+        using apply = std::multimap<Key, Val, std::less<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::unordered_map> {
+        template <class Key, class Val, class... Args>
+        using apply = std::unordered_map<Key, Val, std::hash<Key>, std::equal_to<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::unordered_multimap> {
+        template <class Key, class Val, class... Args>
+        using apply = std::unordered_multimap<Key, Val, std::hash<Key>, std::equal_to<Key>, Args...>;
+    };
+
+    template <template <class...> class C, class Key, class Val, class... Args>
+    using deduce_container = typename deduce_container_impl<C>::template apply<Key, Val, Args...>;
+
+    template <template <class...> class C>
+    static void test_copy_move() {
+        using Container = C<int, std::string_view>;
+        const auto c    = ranges::to<Container>(some_pairs);
+
+        // validate the "direct" construction path with some copies and moves
+        {
+            std::same_as<Container> auto c0 = ranges::to<Container>(ranges::to<Container>(some_pairs));
+            assert(c0 == c);
+        }
+        {
+            std::same_as<Container> auto c1 = ranges::to<Container>(c);
+            assert(c1 == c);
+        }
+        {
+            std::same_as<Container> auto c2 = ranges::to<C>(ranges::to<Container>(some_pairs));
+            assert(c2 == c);
+        }
+        {
+            std::same_as<Container> auto c3 = ranges::to<C>(c);
+            assert(c3 == c);
+        }
+        {
+            std::same_as<Container> auto c4 = ranges::to<Container>(some_pairs) | ranges::to<Container>();
+            assert(c4 == c);
+        }
+        {
+            std::same_as<Container> auto c5 = c | ranges::to<Container>();
+            assert(c5 == c);
+        }
+        {
+            std::same_as<Container> auto c6 = ranges::to<Container>(some_pairs) | ranges::to<C>();
+            assert(c6 == c);
+        }
+        {
+            std::same_as<Container> auto c7 = c | ranges::to<C>();
+            assert(c7 == c);
+        }
+    }
+
+    template <ranges::input_range R, template <class...> class C, is_multi Multi>
+    static void test_mappish() {
+        auto& expected = []() -> auto& {
+            if constexpr (Multi == is_multi::yes) {
+                return some_pairs;
+            } else {
+                return unique_pairs;
+            }
+        }
+        ();
+
+        using Container = C<int, std::string_view>;
+        {
+            std::same_as<Container> auto c0 = ranges::to<Container>(R{some_pairs});
+            assert(ranges::is_permutation(c0, expected, any_pair_eq));
+        }
+        {
+            std::same_as<Container> auto c1 = ranges::to<C>(R{some_pairs});
+            assert(ranges::is_permutation(c1, expected, any_pair_eq));
+        }
+        {
+            std::same_as<Container> auto c2 = R{some_pairs} | ranges::to<Container>();
+            assert(ranges::is_permutation(c2, expected, any_pair_eq));
+        }
+        {
+            std::same_as<Container> auto c3 = R{some_pairs} | ranges::to<C>();
+            assert(ranges::is_permutation(c3, expected, any_pair_eq));
+        }
+
+        using Alloc = myalloc<std::pair<const int, std::string_view>>;
+        using T     = deduce_container<C, int, std::string_view, Alloc>;
+
+        {
+            std::same_as<T> auto c4 = ranges::to<T>(R{some_pairs}, Alloc{13});
+            assert(c4.get_allocator().state == 13);
+            assert(ranges::is_permutation(c4, expected, any_pair_eq));
+        }
+        {
+            std::same_as<T> auto c5 = ranges::to<C>(R{some_pairs}, Alloc{13});
+            assert(c5.get_allocator().state == 13);
+            assert(ranges::is_permutation(c5, expected, any_pair_eq));
+        }
+        {
+            std::same_as<T> auto c6 = R{some_pairs} | ranges::to<T>(Alloc{13});
+            assert(c6.get_allocator().state == 13);
+            assert(ranges::is_permutation(c6, expected, any_pair_eq));
+        }
+        {
+            std::same_as<T> auto c7 = R{some_pairs} | ranges::to<C>(Alloc{13});
+            assert(c7.get_allocator().state == 13);
+            assert(ranges::is_permutation(c7, expected, any_pair_eq));
+        }
+    }
+
+    template <ranges::input_range R>
+    static void call() {
+        if constexpr (std::same_as<std::remove_cvref_t<ranges::range_reference_t<R>>,
+                          std::pair<int, std::string_view>>) {
+            test_mappish<R, std::map, is_multi::no>();
+            test_mappish<R, std::multimap, is_multi::yes>();
+            test_mappish<R, std::unordered_map, is_multi::no>();
+            test_mappish<R, std::unordered_multimap, is_multi::yes>();
+        }
+    }
+};
+
+struct settish_instantiator {
+    static constexpr int some_ints[]   = {0, 1, 1, 1, 2, 3, 4, 5, 5, 6, 7};
+    static constexpr int unique_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+    enum class is_multi : bool { no, yes };
+
+    template <template <class...> class C>
+    struct deduce_container_impl; // not defined
+    template <>
+    struct deduce_container_impl<std::set> {
+        template <class Key, class... Args>
+        using apply = std::set<Key, std::less<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::multiset> {
+        template <class Key, class... Args>
+        using apply = std::multiset<Key, std::less<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::unordered_set> {
+        template <class Key, class... Args>
+        using apply = std::unordered_set<Key, std::hash<Key>, std::equal_to<Key>, Args...>;
+    };
+    template <>
+    struct deduce_container_impl<std::unordered_multiset> {
+        template <class Key, class... Args>
+        using apply = std::unordered_multiset<Key, std::hash<Key>, std::equal_to<Key>, Args...>;
+    };
+
+    template <template <class...> class C, class Key, class... Args>
+    using deduce_container = typename deduce_container_impl<C>::template apply<Key, Args...>;
+
+    template <template <class...> class C>
+    static void test_copy_move() {
+        using Container = C<int>;
+        const auto c    = ranges::to<Container>(some_ints);
+
+        // validate the "direct" construction path with some copies and moves
+        {
+            std::same_as<Container> auto c0 = ranges::to<Container>(ranges::to<Container>(some_ints));
+            assert(c0 == c);
+        }
+        {
+            std::same_as<Container> auto c1 = ranges::to<Container>(c);
+            assert(c1 == c);
+        }
+        {
+            std::same_as<Container> auto c2 = ranges::to<C>(ranges::to<Container>(some_ints));
+            assert(c2 == c);
+        }
+        {
+            std::same_as<Container> auto c3 = ranges::to<C>(c);
+            assert(c3 == c);
+        }
+        {
+            std::same_as<Container> auto c4 = ranges::to<Container>(some_ints) | ranges::to<Container>();
+            assert(c4 == c);
+        }
+        {
+            std::same_as<Container> auto c5 = c | ranges::to<Container>();
+            assert(c5 == c);
+        }
+        {
+            std::same_as<Container> auto c6 = ranges::to<Container>(some_ints) | ranges::to<C>();
+            assert(c6 == c);
+        }
+        {
+            std::same_as<Container> auto c7 = c | ranges::to<C>();
+            assert(c7 == c);
+        }
+    }
+
+    template <ranges::input_range R, template <class...> class C, is_multi Multi>
+    static void test_settish() {
+        auto& expected = []() -> auto& {
+            if constexpr (Multi == is_multi::yes) {
+                return some_ints;
+            } else {
+                return unique_ints;
+            }
+        }
+        ();
+
+        using Container = C<int>;
+        {
+            std::same_as<Container> auto c0 = ranges::to<Container>(R{some_ints});
+            assert(ranges::is_permutation(c0, expected));
+        }
+        {
+            std::same_as<Container> auto c1 = ranges::to<C>(R{some_ints});
+            assert(ranges::is_permutation(c1, expected));
+        }
+        {
+            std::same_as<Container> auto c2 = R{some_ints} | ranges::to<Container>();
+            assert(ranges::is_permutation(c2, expected));
+        }
+        {
+            std::same_as<Container> auto c3 = R{some_ints} | ranges::to<C>();
+            assert(ranges::is_permutation(c3, expected));
+        }
+
+        using Alloc = myalloc<int>;
+        using T     = deduce_container<C, int, Alloc>;
+
+        {
+            std::same_as<T> auto c4 = ranges::to<T>(R{some_ints}, Alloc{13});
+            assert(c4.get_allocator().state == 13);
+            assert(ranges::is_permutation(c4, expected));
+        }
+        {
+            std::same_as<T> auto c5 = ranges::to<C>(R{some_ints}, Alloc{13});
+            assert(c5.get_allocator().state == 13);
+            assert(ranges::is_permutation(c5, expected));
+        }
+        {
+            std::same_as<T> auto c6 = R{some_ints} | ranges::to<T>(Alloc{13});
+            assert(c6.get_allocator().state == 13);
+            assert(ranges::is_permutation(c6, expected));
+        }
+        {
+            std::same_as<T> auto c7 = R{some_ints} | ranges::to<C>(Alloc{13});
+            assert(c7.get_allocator().state == 13);
+            assert(ranges::is_permutation(c7, expected));
+        }
+    }
+
+    template <ranges::input_range R>
+    static void call() {
+        test_settish<R, std::set, is_multi::no>();
+        test_settish<R, std::multiset, is_multi::yes>();
+        test_settish<R, std::unordered_set, is_multi::no>();
+        test_settish<R, std::unordered_multiset, is_multi::yes>();
+    }
+};
+
+struct secret_key_t {
+    explicit secret_key_t() = default;
+};
+inline constexpr secret_key_t secret_key;
+
+struct reservable {
+    using value_type = int;
+
+    std::size_t cap_      = 0;
+    std::size_t reserved_ = 0;
+    std::size_t size_     = 0;
+
+    constexpr reservable(secret_key_t) {}
+
+    constexpr std::size_t capacity() const {
+        return cap_;
+    }
+    constexpr std::size_t max_size() const {
+        return ~std::size_t{};
+    }
+    constexpr std::size_t size() const {
+        return size_;
+    }
+    constexpr void reserve(const std::size_t n) {
+        if (n > cap_) {
+            assert(reserved_ == 0);
+            reserved_ = n;
+            cap_      = n;
+        }
+    }
+
+    constexpr void push_back(int) {
+        if (++size_ > cap_) {
+            assert(false);
+        }
+    }
+
+    int* begin(); // not defined
+    int* end(); // not defined
+};
+
+constexpr bool test_reservable() {
+    int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    {
+        std::same_as<reservable> auto r = some_ints | ranges::to<reservable>(secret_key);
+        assert(r.size_ == ranges::size(some_ints));
+        assert(r.cap_ == ranges::size(some_ints));
+        assert(r.reserved_ == ranges::size(some_ints));
+    }
+
+    return true;
+}
+
+constexpr bool test_common_constructible() {
+    struct common_constructible {
+        using value_type = int;
+
+        constexpr common_constructible(const int* const first, const int* const last, secret_key_t)
+            : first_{first}, last_{last} {}
+
+        const int* begin() const; // not defined
+        const int* end() const; // not defined
+
+        const int* first_;
+        const int* last_;
+    };
+
+    int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+    {
+        std::same_as<common_constructible> auto c0 = ranges::to<common_constructible>(some_ints, secret_key);
+        assert(c0.first_ == ranges::begin(some_ints));
+        assert(c0.last_ == ranges::end(some_ints));
+    }
+    {
+        std::same_as<common_constructible> auto c1 = some_ints | ranges::to<common_constructible>(secret_key);
+        assert(c1.first_ == ranges::begin(some_ints));
+        assert(c1.last_ == ranges::end(some_ints));
+    }
+
+    return true;
+}
+
+constexpr bool test_nested_range() {
+    int some_int_ervals[3][2][2] = {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}, {{8, 9}, {10, 11}}};
+
+    using C = std::vector<std::vector<std::vector<int>>>;
+
+    {
+        std::same_as<C> auto c0 = ranges::to<C>(some_int_ervals);
+        assert(c0.size() == 3);
+        assert(c0[0].size() == 2);
+        assert(c0[0][0].size() == 2);
+        assert(c0[0][0][0] == 0);
+        assert(c0[0][0][1] == 1);
+        assert(c0[0][1][0] == 2);
+        assert(c0[0][1][1] == 3);
+        assert(c0[1][0][0] == 4);
+        assert(c0[1][0][1] == 5);
+        assert(c0[1][1][0] == 6);
+        assert(c0[1][1][1] == 7);
+        assert(c0[2][0][0] == 8);
+        assert(c0[2][0][1] == 9);
+        assert(c0[2][1][0] == 10);
+        assert(c0[2][1][1] == 11);
+    }
+    {
+        std::same_as<C> auto c0 = some_int_ervals | ranges::to<C>();
+        assert(c0.size() == 3);
+        assert(c0[0].size() == 2);
+        assert(c0[0][0].size() == 2);
+        assert(c0[0][0][0] == 0);
+        assert(c0[0][0][1] == 1);
+        assert(c0[0][1][0] == 2);
+        assert(c0[0][1][1] == 3);
+        assert(c0[1][0][0] == 4);
+        assert(c0[1][0][1] == 5);
+        assert(c0[1][1][0] == 6);
+        assert(c0[1][1][1] == 7);
+        assert(c0[2][0][0] == 8);
+        assert(c0[2][0][1] == 9);
+        assert(c0[2][1][0] == 10);
+        assert(c0[2][1][1] == 11);
+    }
+
+    return true;
+}
+
+int main() {
+    test_in<sequence_instantiator, const char>();
+    test_in<mappish_instantiator, const std::pair<int, std::string_view>>();
+    test_in<settish_instantiator, const int>();
+
+    sequence_instantiator::test_copy_move<std::basic_string>();
+    sequence_instantiator::test_copy_move<std::deque>();
+    sequence_instantiator::test_copy_move<std::forward_list>();
+    sequence_instantiator::test_copy_move<std::list>();
+    sequence_instantiator::test_copy_move<std::vector>();
+#ifdef __cpp_lib_constexpr_string
+    static_assert(sequence_instantiator::test_copy_move<std::basic_string>());
+#endif // __cpp_lib_constexpr_string
+#ifdef __cpp_lib_constexpr_vector
+    static_assert(sequence_instantiator::test_copy_move<std::vector>());
+#endif // __cpp_lib_constexpr_vector
+
+    mappish_instantiator::test_copy_move<std::map>();
+    mappish_instantiator::test_copy_move<std::multimap>();
+    mappish_instantiator::test_copy_move<std::unordered_map>();
+    mappish_instantiator::test_copy_move<std::unordered_multimap>();
+
+    settish_instantiator::test_copy_move<std::set>();
+    settish_instantiator::test_copy_move<std::multiset>();
+    settish_instantiator::test_copy_move<std::unordered_set>();
+    settish_instantiator::test_copy_move<std::unordered_multiset>();
+
+    test_reservable();
+    static_assert(test_reservable());
+
+    test_common_constructible();
+    static_assert(test_common_constructible());
+
+    test_nested_range();
+#if defined(__cpp_lib_constexpr_vector) && (defined(__clang__) || defined(__EDG__))
+    static_assert(test_nested_range());
+#endif // defined(__cpp_lib_constexpr_vector) && (defined(__clang__) || defined(__EDG__))
+}
diff --git a/tests/std/tests/P1206R7_set_from_range/env.lst b/tests/std/tests/P1206R7_set_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_set_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_set_from_range/test.cpp b/tests/std/tests/P1206R7_set_from_range/test.cpp
new file mode 100644
index 0000000000..5697797fb9
--- /dev/null
+++ b/tests/std/tests/P1206R7_set_from_range/test.cpp
@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <set>
+#include <span>
+#include <type_traits>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_set(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        set<int> m{from_range, forward<Rng>(rng)};
+        assert(ranges::equal(m, expected));
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
+
+struct set_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_set(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_set(s);
+}
+
+void test_move_only_views() {
+    test_set(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_set(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_set(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_set(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_set(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_set(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<set_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_set_insert_range/env.lst b/tests/std/tests/P1206R7_set_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_set_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_set_insert_range/test.cpp b/tests/std/tests/P1206R7_set_insert_range/test.cpp
new file mode 100644
index 0000000000..4441e8e367
--- /dev/null
+++ b/tests/std/tests/P1206R7_set_insert_range/test.cpp
@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <set>
+#include <span>
+#include <type_traits>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_set(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        set<int> m;
+        m.insert_range(forward<Rng>(rng));
+        assert(ranges::equal(m, expected));
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
+
+struct set_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_set(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_set(s);
+}
+
+void test_move_only_views() {
+    test_set(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_set(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_set(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_set(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_set(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_set(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_set(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<set_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_stack_from_range/env.lst b/tests/std/tests/P1206R7_stack_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_stack_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_stack_from_range/test.cpp b/tests/std/tests/P1206R7_stack_from_range/test.cpp
new file mode 100644
index 0000000000..c6029f5ed5
--- /dev/null
+++ b/tests/std/tests/P1206R7_stack_from_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <new>
+#include <ranges>
+#include <span>
+#include <stack>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range R, class... Args>
+void test_stack(R&& r, Args&&... args) {
+    adaptor_adaptor<stack<int>> s{from_range, r, forward<Args>(args)...};
+    assert(ranges::equal(s.get_container(), some_ints));
+}
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_stack(R{some_ints});
+        test_stack(R{some_ints}, allocator<int>{});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+int main() {
+    // Validate views
+    { // copyable views
+        constexpr span<const int> s{some_ints};
+        test_stack(s);
+    }
+
+    { // move-only views
+        test_stack(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+        test_stack(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+        test_stack(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+        test_stack(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+        test_stack(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+        test_stack(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+        test_stack(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+    }
+
+    // Validate non-views
+    test_stack(some_ints); // C array
+
+    { // lvalue vector
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_stack(vec);
+    }
+
+    { // lvalue forward_list
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_stack(lst);
+    }
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_stack_push_range/env.lst b/tests/std/tests/P1206R7_stack_push_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_stack_push_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_stack_push_range/test.cpp b/tests/std/tests/P1206R7_stack_push_range/test.cpp
new file mode 100644
index 0000000000..deb7a6035f
--- /dev/null
+++ b/tests/std/tests/P1206R7_stack_push_range/test.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <deque>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <stack>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct adaptor_adaptor : T {
+    using T::T;
+
+    auto& get_container() {
+        return this->c;
+    }
+    auto& get_container() const {
+        return this->c;
+    }
+};
+
+template <ranges::input_range Rng, size_t N>
+void test_stack(const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    adaptor_adaptor<stack<int>> d{deque<int>(presize, -1)};
+
+    d.push_range(forward<Rng>(rng));
+    const auto count      = static_cast<ptrdiff_t>(presize);
+    const auto& container = d.get_container();
+    assert(ranges::count(container | views::take(count), -1) == count);
+    assert(ranges::equal(container | views::drop(count), expected));
+}
+
+template <ranges::input_range Rng, size_t N>
+void test_stack(const int (&expected)[N]) {
+    test_stack(0, Rng{expected}, expected);
+    test_stack(2, Rng{expected}, expected);
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_stack<R>(some_ints);
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_view() {
+    test_stack<span<const int>>(some_ints);
+}
+
+void test_move_only_view() {
+    test_stack<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_stack<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_stack<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_stack<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_stack<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_stack<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_stack<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+}
+
+void test_c_array() {
+    test_stack(0, some_ints, some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(from_range, some_ints);
+    test_stack(0, vec, some_ints);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_stack(0, lst, some_ints);
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    test_move_only_view();
+
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_string_append_range/env.lst b/tests/std/tests/P1206R7_string_append_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_append_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_string_append_range/test.cpp b/tests/std/tests/P1206R7_string_append_range/test.cpp
new file mode 100644
index 0000000000..146e617594
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_append_range/test.cpp
@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(const size_t capacity, const size_t presize, Rng&& rng, const T (&expected)[N]) {
+    basic_string<T> str;
+    str.reserve(capacity);
+    str.resize(presize, T{'x'});
+
+    str.append_range(forward<Rng>(rng));
+    const auto length = static_cast<int>(presize);
+    assert(ranges::count(str | views::take(length), T{'x'}) == length);
+    assert(ranges::equal(str | views::drop(length), expected));
+
+    return true;
+}
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(const T (&expected)[N]) {
+    test_string(0, 0, Rng{expected}, expected);
+    test_string(ranges::size(expected) + 2, 2, Rng{expected}, expected);
+
+    return true;
+}
+
+static constexpr char some_chars[] = "Hello, world!";
+
+struct string_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_string<R>(some_chars);
+        STATIC_ASSERT(test_string<R>(some_chars));
+    }
+};
+
+static constexpr wchar_t some_wchars[] = L"Hello, world!";
+
+struct wstring_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_string<R>(some_wchars);
+        STATIC_ASSERT(test_string<R>(some_wchars));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const char, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_view() {
+    test_string<span<const char>>(some_chars);
+    test_string<span<const wchar_t>>(some_wchars);
+    return true;
+}
+
+constexpr bool test_move_only_view() {
+    test_string<move_only_view<input_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<forward_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<forward_iterator_tag, test::Common::yes>>(some_chars);
+    test_string<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_chars);
+    test_string<move_only_view<random_access_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_chars);
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_string(0, 0, some_chars, some_chars);
+    test_string(0, 0, some_wchars, some_wchars);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(from_range, some_chars);
+        test_string(0, 0, vec, some_chars);
+    }
+    {
+        vector vec(from_range, some_wchars);
+        test_string(0, 0, vec, some_wchars);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_chars), ranges::end(some_chars));
+        test_string(0, 0, lst, some_chars);
+    }
+    {
+        forward_list lst(ranges::begin(some_wchars), ranges::end(some_wchars));
+        test_string(0, 0, lst, some_wchars);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    STATIC_ASSERT(test_copyable_view());
+    test_move_only_view();
+    STATIC_ASSERT(test_move_only_view());
+
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<string_instantiator, const char>();
+    test_in<wstring_instantiator, const wchar_t>();
+}
diff --git a/tests/std/tests/P1206R7_string_assign_range/env.lst b/tests/std/tests/P1206R7_string_assign_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_assign_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_string_assign_range/test.cpp b/tests/std/tests/P1206R7_string_assign_range/test.cpp
new file mode 100644
index 0000000000..af273b55a4
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_assign_range/test.cpp
@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(const size_t capacity, const size_t presize, Rng&& rng, const T (&expected)[N]) {
+    basic_string<T> str;
+    str.reserve(capacity);
+    str.resize(presize, T{'x'});
+
+    str.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(str, expected));
+
+    return true;
+}
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(const T (&expected)[N]) {
+    test_string(0, 0, Rng{expected}, expected);
+    test_string(ranges::size(expected) + 2, 2, Rng{expected}, expected);
+
+    return true;
+}
+
+static constexpr char some_chars[] = "Hello, world!";
+
+struct string_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_string<R>(some_chars);
+        STATIC_ASSERT(test_string<R>(some_chars));
+    }
+};
+
+static constexpr wchar_t some_wchars[] = L"Hello, world!";
+
+struct wstring_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_string<R>(some_wchars);
+        STATIC_ASSERT(test_string<R>(some_wchars));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const char, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_view() {
+    test_string<span<const char>>(some_chars);
+    test_string<span<const wchar_t>>(some_wchars);
+    return true;
+}
+
+constexpr bool test_move_only_view() {
+    test_string<move_only_view<input_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<forward_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<forward_iterator_tag, test::Common::yes>>(some_chars);
+    test_string<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_chars);
+    test_string<move_only_view<random_access_iterator_tag, test::Common::no>>(some_chars);
+    test_string<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_chars);
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_string(0, 0, some_chars, some_chars);
+    test_string(0, 0, some_wchars, some_wchars);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(from_range, some_chars);
+        test_string(0, 0, vec, some_chars);
+    }
+    {
+        vector vec(from_range, some_wchars);
+        test_string(0, 0, vec, some_wchars);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_chars), ranges::end(some_chars));
+        test_string(0, 0, lst, some_chars);
+    }
+    {
+        forward_list lst(ranges::begin(some_wchars), ranges::end(some_wchars));
+        test_string(0, 0, lst, some_wchars);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    STATIC_ASSERT(test_copyable_view());
+    test_move_only_view();
+    STATIC_ASSERT(test_move_only_view());
+
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<string_instantiator, const char>();
+    test_in<wstring_instantiator, const wchar_t>();
+}
diff --git a/tests/std/tests/P1206R7_string_from_range/env.lst b/tests/std/tests/P1206R7_string_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_string_from_range/test.cpp b/tests/std/tests/P1206R7_string_from_range/test.cpp
new file mode 100644
index 0000000000..494a258b4e
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_from_range/test.cpp
@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <class T>
+struct c_string {
+    const T* ptr_ = nullptr;
+
+    struct sentinel {
+        constexpr bool operator==(const T* p) const {
+            return *p == 0;
+        }
+    };
+
+    constexpr const T* begin() const {
+        return ptr_;
+    }
+    constexpr sentinel end() const {
+        return {};
+    }
+};
+
+template <ranges::input_range Rng, class T>
+constexpr bool test_string(Rng&& rng, const T* expected) {
+    basic_string<T> str(from_range, forward<Rng>(rng));
+    assert(ranges::equal(str, c_string<T>{expected}));
+
+    return true;
+}
+
+static constexpr const char hw[]    = "Hello, world!";
+static constexpr const auto span_hw = span{hw}.first<span{hw}.size() - 1>();
+
+struct string_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_string(R{span_hw}, hw);
+        STATIC_ASSERT(test_string(R{span_hw}, hw));
+    }
+};
+
+static constexpr const wchar_t whw[] = L"Hello, world!";
+static constexpr const auto span_whw = span{whw}.first<span{whw}.size() - 1>();
+
+struct wstring_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_string(R{span_whw}, whw);
+        STATIC_ASSERT(test_string(R{span_whw}, whw));
+    }
+};
+
+template <class Category, class CharT, test::Common IsCommon,
+    bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const CharT, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    test_string(span_hw, hw);
+    test_string(span_whw, whw);
+
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    test_string(move_only_view<input_iterator_tag, char, test::Common::no>{span_hw}, hw);
+    test_string(move_only_view<forward_iterator_tag, char, test::Common::no>{span_hw}, hw);
+    test_string(move_only_view<forward_iterator_tag, char, test::Common::yes>{span_hw}, hw);
+    test_string(move_only_view<bidirectional_iterator_tag, char, test::Common::no>{span_hw}, hw);
+    test_string(move_only_view<bidirectional_iterator_tag, char, test::Common::yes>{span_hw}, hw);
+    test_string(move_only_view<random_access_iterator_tag, char, test::Common::no>{span_hw}, hw);
+    test_string(move_only_view<random_access_iterator_tag, char, test::Common::yes>{span_hw}, hw);
+
+    test_string(move_only_view<input_iterator_tag, wchar_t, test::Common::no>{span_whw}, whw);
+    test_string(move_only_view<forward_iterator_tag, wchar_t, test::Common::no>{span_whw}, whw);
+    test_string(move_only_view<forward_iterator_tag, wchar_t, test::Common::yes>{span_whw}, whw);
+    test_string(move_only_view<bidirectional_iterator_tag, wchar_t, test::Common::no>{span_whw}, whw);
+    test_string(move_only_view<bidirectional_iterator_tag, wchar_t, test::Common::yes>{span_whw}, whw);
+    test_string(move_only_view<random_access_iterator_tag, wchar_t, test::Common::no>{span_whw}, whw);
+    test_string(move_only_view<random_access_iterator_tag, wchar_t, test::Common::yes>{span_whw}, whw);
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_string(span_hw, hw);
+    test_string(span_whw, whw);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(span_hw.data(), span_hw.data() + span_hw.size());
+        test_string(vec, hw);
+    }
+    {
+        vector vec(span_whw.data(), span_whw.data() + span_whw.size());
+        test_string(vec, whw);
+    }
+
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(span_hw.data(), span_hw.data() + span_hw.size());
+        test_string(lst, hw);
+    }
+    {
+        forward_list lst(span_whw.data(), span_whw.data() + span_whw.size());
+        test_string(lst, whw);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+
+    test_lvalue_forward_list();
+
+    test_in<string_instantiator, const char>();
+    test_in<wstring_instantiator, const wchar_t>();
+}
diff --git a/tests/std/tests/P1206R7_string_insert_range/env.lst b/tests/std/tests/P1206R7_string_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_string_insert_range/test.cpp b/tests/std/tests/P1206R7_string_insert_range/test.cpp
new file mode 100644
index 0000000000..0d8fdc399a
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_insert_range/test.cpp
@@ -0,0 +1,130 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(const size_t presize, const int offset, Rng&& rng, const T (&expected)[N]) {
+    assert(static_cast<size_t>(offset) <= presize);
+    basic_string<T> str(presize, T{'x'});
+    const same_as<typename basic_string<T>::iterator> auto result =
+        str.insert_range(str.begin() + offset, forward<Rng>(rng));
+    assert(result == str.begin() + offset);
+    const auto n = static_cast<int>(ranges::size(expected));
+    assert(ranges::count(str | views::take(offset), T{'x'}) == offset);
+    assert(ranges::equal(str | views::drop(offset) | views::take(n), expected));
+    assert(ranges::count(str | views::drop(offset + n), T{'x'}) == static_cast<int>(presize - offset));
+
+    return true;
+}
+
+static constexpr char hw[]     = "Hello, World!";
+static constexpr wchar_t whw[] = L"Hello, World!";
+
+struct string_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        // clang-format off
+        constexpr auto& text = []() -> auto& {
+            if constexpr (is_same_v<ranges::range_value_t<R>, char>) {
+                return hw;
+            } else {
+                return whw;
+            }
+        }();
+        // clang-format on
+
+        test_string(0, 0, R{text}, text);
+        STATIC_ASSERT(test_string(0, 0, R{text}, text));
+
+        test_string(5, 0, R{text}, text);
+        STATIC_ASSERT(test_string(5, 0, R{text}, text));
+
+        test_string(5, 2, R{text}, text);
+        STATIC_ASSERT(test_string(5, 2, R{text}, text));
+
+        test_string(5, 5, R{text}, text);
+        STATIC_ASSERT(test_string(5, 5, R{text}, text));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const char, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    test_string(0, 0, span<const char>{hw}, hw);
+    test_string(0, 0, span<const wchar_t>{whw}, whw);
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    test_string(0, 0, move_only_view<input_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(0, 0, move_only_view<forward_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(0, 0, move_only_view<forward_iterator_tag, test::Common::yes>{hw}, hw);
+    test_string(0, 0, move_only_view<bidirectional_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(0, 0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{hw}, hw);
+    test_string(0, 0, move_only_view<random_access_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(0, 0, move_only_view<random_access_iterator_tag, test::Common::yes>{hw}, hw);
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_string(0, 0, hw, hw);
+    test_string(0, 0, whw, whw);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(ranges::begin(hw), ranges::end(hw));
+        test_string(0, 0, vec, hw);
+    }
+    {
+        vector vec(ranges::begin(whw), ranges::end(whw));
+        test_string(0, 0, vec, whw);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(hw), ranges::end(hw));
+        test_string(0, 0, lst, hw);
+    }
+    {
+        forward_list lst(ranges::begin(whw), ranges::end(whw));
+        test_string(0, 0, lst, whw);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<string_instantiator, const char>();
+    test_in<string_instantiator, const wchar_t>();
+}
diff --git a/tests/std/tests/P1206R7_string_replace_with_range/env.lst b/tests/std/tests/P1206R7_string_replace_with_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_replace_with_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_string_replace_with_range/test.cpp b/tests/std/tests/P1206R7_string_replace_with_range/test.cpp
new file mode 100644
index 0000000000..1693297c14
--- /dev/null
+++ b/tests/std/tests/P1206R7_string_replace_with_range/test.cpp
@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, class T, size_t N>
+constexpr bool test_string(
+    const size_t presize, const int offset, const int length, Rng&& rng, const T (&expected)[N]) {
+    assert(static_cast<size_t>(offset) + length <= presize);
+    basic_string<T> str(from_range, views::iota(T{'a'}, T('a' + presize)));
+    same_as<basic_string<T>> auto& result =
+        str.replace_with_range(str.begin() + offset, str.begin() + offset + length, forward<Rng>(rng));
+    assert(&result == &str);
+
+    const auto n = static_cast<int>(ranges::size(expected));
+    assert(ranges::equal(str | views::take(offset), views::iota(T{'a'}, T('a' + offset))));
+    assert(ranges::equal(str | views::drop(offset) | views::take(n), expected));
+    assert(ranges::equal(str | views::drop(offset + n), views::iota(T('a' + offset + length), T('a' + presize))));
+
+    return true;
+}
+
+static constexpr char hw[]     = "Hello, World!";
+static constexpr wchar_t whw[] = L"Hello, World!";
+
+struct string_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        // clang-format off
+        constexpr auto& text = []() -> auto& {
+            if constexpr (is_same_v<ranges::range_value_t<R>, char>) {
+                return hw;
+            } else {
+                return whw;
+            }
+        }();
+        // clang-format on
+
+        // insert into empty
+        test_string(0, 0, 0, R{text}, text);
+        STATIC_ASSERT(test_string(0, 0, 0, R{text}, text));
+
+        // prepend
+        test_string(5, 0, 0, R{text}, text);
+        STATIC_ASSERT(test_string(5, 0, 0, R{text}, text));
+
+        // expansion
+        test_string(5, 2, 1, R{text}, text);
+        STATIC_ASSERT(test_string(5, 2, 1, R{text}, text));
+
+        // append
+        test_string(5, 5, 0, R{text}, text);
+        STATIC_ASSERT(test_string(5, 5, 0, R{text}, text));
+
+        // insert into non-empty
+        test_string(26, 5, 0, R{text}, text);
+        STATIC_ASSERT(test_string(26, 5, 0, R{text}, text));
+
+        // contraction
+        test_string(26, 5, 20, R{text}, text);
+        STATIC_ASSERT(test_string(26, 5, 20, R{text}, text));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const char, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    test_string(10, 4, 6, span<const char>{hw}, hw);
+    test_string(10, 4, 6, span<const wchar_t>{whw}, whw);
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    test_string(4, 0, 1, move_only_view<input_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<forward_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<forward_iterator_tag, test::Common::yes>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<bidirectional_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<bidirectional_iterator_tag, test::Common::yes>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<random_access_iterator_tag, test::Common::no>{hw}, hw);
+    test_string(4, 0, 1, move_only_view<random_access_iterator_tag, test::Common::yes>{hw}, hw);
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_string(2, 1, 1, hw, hw);
+    test_string(2, 1, 1, whw, whw);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(ranges::begin(hw), ranges::end(hw));
+        test_string(0, 0, 0, vec, hw);
+    }
+    {
+        vector vec(ranges::begin(whw), ranges::end(whw));
+        test_string(1, 0, 0, vec, whw);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(hw), ranges::end(hw));
+        test_string(20, 1, 18, lst, hw);
+    }
+    {
+        forward_list lst(ranges::begin(whw), ranges::end(whw));
+        test_string(20, 1, 18, lst, whw);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<string_instantiator, const char>();
+    test_in<string_instantiator, const wchar_t>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_map_from_range/env.lst b/tests/std/tests/P1206R7_unordered_map_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_map_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
new file mode 100644
index 0000000000..cc8dabb4ba
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_unordered_map(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_map<int, int> m{from_range, forward<Rng>(rng)};
+        unordered_map<int, int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+
+struct unordered_map_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_map(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_unordered_map(s);
+}
+
+void test_move_only_views() {
+    test_unordered_map(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_map(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_map(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_unordered_map(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_map(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_map(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_map_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_map_insert_range/env.lst b/tests/std/tests/P1206R7_unordered_map_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_map_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
new file mode 100644
index 0000000000..ddd7785e4f
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_unordered_map(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_map<int, int> m;
+        m.insert_range(forward<Rng>(rng));
+        unordered_map<int, int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+
+struct unordered_map_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_map(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_unordered_map(s);
+}
+
+void test_move_only_views() {
+    test_unordered_map(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_map(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_map(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_map(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_unordered_map(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_map(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_map(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_map_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_multimap_from_range/env.lst b/tests/std/tests/P1206R7_unordered_multimap_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multimap_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
new file mode 100644
index 0000000000..c3033a72ae
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 100}, {4, 101}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_unordered_multimap(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_multimap<int, int> m{from_range, forward<Rng>(rng)};
+        unordered_multimap<int, int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {4, 100}, {0, 20}, {5, 15}, {4, 101}, {6, 14}, {7, 13}, {1, 19}};
+
+struct unordered_multimap_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_multimap(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_unordered_multimap(s);
+}
+
+void test_move_only_views() {
+    test_unordered_multimap(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_multimap(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_multimap(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_unordered_multimap(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_multimap(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_multimap(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_multimap_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_multimap_insert_range/env.lst b/tests/std/tests/P1206R7_unordered_multimap_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multimap_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
new file mode 100644
index 0000000000..94adfcb761
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr pair<int, int> expected[] = {
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 100}, {4, 101}, {5, 15}, {6, 14}, {7, 13}};
+
+template <ranges::input_range Rng>
+void test_unordered_multimap(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_multimap<int, int> m;
+        m.insert_range(forward<Rng>(rng));
+        unordered_multimap<int, int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {4, 100}, {0, 20}, {5, 15}, {4, 101}, {6, 14}, {7, 13}, {1, 19}};
+
+struct unordered_multimap_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_multimap(R{some_pairs});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const pair<int, int>, test::Sized{is_random},
+    test::CanDifference{is_random}, IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef::no, test::CanView::yes, test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const pair<int, int>> s{some_pairs};
+    test_unordered_multimap(s);
+}
+
+void test_move_only_views() {
+    test_unordered_multimap(move_only_view<input_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<forward_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<forward_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_multimap(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_pairs});
+    test_unordered_multimap(move_only_view<random_access_iterator_tag, test::Common::no>{some_pairs});
+    test_unordered_multimap(move_only_view<random_access_iterator_tag, test::Common::yes>{some_pairs});
+}
+
+void test_c_array() {
+    test_unordered_multimap(some_pairs);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_multimap(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_pairs), ranges::end(some_pairs));
+    test_unordered_multimap(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_multimap_instantiator, const pair<int, int>>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_multiset_from_range/env.lst b/tests/std/tests/P1206R7_unordered_multiset_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multiset_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_multiset_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_multiset_from_range/test.cpp
new file mode 100644
index 0000000000..7a3330915b
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multiset_from_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 4, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_unordered_multiset(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_multiset<int> m{from_range, forward<Rng>(rng)};
+        unordered_multiset<int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 6, 4, 7, 1};
+
+struct unordered_multiset_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_multiset(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_unordered_multiset(s);
+}
+
+void test_move_only_views() {
+    test_unordered_multiset(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_multiset(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_multiset(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_unordered_multiset(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_multiset(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_multiset(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_multiset_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_multiset_insert_range/env.lst b/tests/std/tests/P1206R7_unordered_multiset_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multiset_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_multiset_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_multiset_insert_range/test.cpp
new file mode 100644
index 0000000000..99f20380b2
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_multiset_insert_range/test.cpp
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 4, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_unordered_multiset(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_multiset<int> m;
+        m.insert_range(forward<Rng>(rng));
+        unordered_multiset<int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 6, 4, 7, 1};
+
+struct unordered_multiset_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_multiset(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_unordered_multiset(s);
+}
+
+void test_move_only_views() {
+    test_unordered_multiset(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_multiset(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_multiset(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_multiset(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_unordered_multiset(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_multiset(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_multiset(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_multiset_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_set_from_range/env.lst b/tests/std/tests/P1206R7_unordered_set_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_set_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
new file mode 100644
index 0000000000..60d99ffb26
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_unordered_set(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_set<int> m{from_range, forward<Rng>(rng)};
+        unordered_set<int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 0, 5, 6, 7, 1};
+
+struct unordered_set_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_set(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_unordered_set(s);
+}
+
+void test_move_only_views() {
+    test_unordered_set(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_set(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_set(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_unordered_set(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_set(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_set(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_set_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_unordered_set_insert_range/env.lst b/tests/std/tests/P1206R7_unordered_set_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_set_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
new file mode 100644
index 0000000000..c9d2a532b4
--- /dev/null
+++ b/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+static constexpr int expected[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+template <ranges::input_range Rng>
+void test_unordered_set(Rng&& rng) {
+    if constexpr (is_reference_v<ranges::range_reference_t<Rng>>) {
+        unordered_set<int> m;
+        m.insert_range(forward<Rng>(rng));
+        unordered_set<int> e{begin(expected), end(expected)};
+        assert(m == e);
+    }
+}
+
+static constexpr int some_ints[] = {4, 2, 3, 0, 5, 6, 7, 1};
+
+struct unordered_set_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_unordered_set(R{some_ints});
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>}, test::ProxyRef::no, test::CanView::yes,
+    test::Copyability::move_only>;
+
+void test_copyable_views() {
+    constexpr span<const int> s{some_ints};
+    test_unordered_set(s);
+}
+
+void test_move_only_views() {
+    test_unordered_set(move_only_view<input_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<forward_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_set(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints});
+    test_unordered_set(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints});
+    test_unordered_set(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints});
+}
+
+void test_c_array() {
+    test_unordered_set(some_ints);
+}
+
+void test_lvalue_vector() {
+    vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_set(vec);
+}
+
+void test_lvalue_forward_list() {
+    forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+    test_unordered_set(lst);
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    test_move_only_views();
+
+    // Validate non-views
+    test_c_array();
+    test_lvalue_vector();
+    test_lvalue_forward_list();
+
+    test_in<unordered_set_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_vector_append_range/env.lst b/tests/std/tests/P1206R7_vector_append_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_append_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_vector_append_range/test.cpp b/tests/std/tests/P1206R7_vector_append_range/test.cpp
new file mode 100644
index 0000000000..df37546f59
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_append_range/test.cpp
@@ -0,0 +1,162 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, size_t N>
+constexpr bool test_vector(const size_t capacity, const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    vector<int> vec;
+    vec.reserve(capacity);
+    vec.resize(presize, -1);
+
+    vec.append_range(forward<Rng>(rng));
+    const auto length = static_cast<ptrdiff_t>(presize);
+    assert(ranges::count(vec | views::take(length), -1) == length);
+    assert(ranges::equal(vec | views::drop(length), expected));
+
+    return true;
+}
+
+template <ranges::input_range Rng, size_t N>
+constexpr bool test_vector(const int (&expected)[N]) {
+    test_vector(0, 0, Rng{expected}, expected);
+    test_vector(ranges::size(expected) + 2, 2, Rng{expected}, expected);
+
+    return true;
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct vector_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_vector<R>(some_ints);
+        STATIC_ASSERT(test_vector<R>(some_ints));
+    }
+};
+
+template <ranges::input_range Rng, size_t N>
+constexpr bool test_vector_boo(const size_t capacity, const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    vector<bool> vec;
+    vec.reserve(capacity);
+    vec.resize(presize, true);
+
+    vec.append_range(forward<Rng>(rng));
+    const auto length = static_cast<ptrdiff_t>(presize);
+    assert(ranges::count(vec | views::take(length), true) == length);
+    assert(ranges::equal(vec | views::drop(length), expected, std::equal_to<bool>{}));
+
+    return true;
+}
+
+template <ranges::input_range Rng, size_t N>
+constexpr bool test_vector_boo(const int (&expected)[N]) {
+    test_vector_boo(0, 0, Rng{expected}, expected);
+    test_vector_boo(ranges::size(expected) + 2, 2, Rng{expected}, expected);
+
+    return true;
+}
+
+static constexpr int other_ints[80] = { //
+    0, 7, 0, 2, 3, 0, 0, 0, 4, 0, 0, 2, 5, 1, 0, 7, //
+    6, 3, 0, 7, 0, 5, 7, 0, 3, 4, 5, 0, 3, 0, 0, 2, //
+    2, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 5, 0, 0, 0, //
+    0, 4, 2, 4, 0, 7, 0, 2, 0, 7, 1, 0, 6, 0, 0, 6, //
+    3, 5, 0, 7, 0, 7, 0, 0, 2, 3, 5, 2, 2, 0, 7, 3};
+
+struct vector_boo_instantiator {
+    template <ranges::input_range R>
+    static constexpr void call() {
+        test_vector_boo<R>(other_ints);
+        STATIC_ASSERT(test_vector_boo<R>(other_ints));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_view() {
+    test_vector<span<const int>>(some_ints);
+    test_vector_boo<span<const int>>(other_ints);
+    return true;
+}
+
+constexpr bool test_move_only_view() {
+    test_vector<move_only_view<input_iterator_tag, test::Common::no>>(some_ints);
+    test_vector<move_only_view<forward_iterator_tag, test::Common::no>>(some_ints);
+    test_vector<move_only_view<forward_iterator_tag, test::Common::yes>>(some_ints);
+    test_vector<move_only_view<bidirectional_iterator_tag, test::Common::no>>(some_ints);
+    test_vector<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(some_ints);
+    test_vector<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
+    test_vector<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
+
+    test_vector_boo<move_only_view<input_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_boo<move_only_view<forward_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_boo<move_only_view<forward_iterator_tag, test::Common::yes>>(other_ints);
+    test_vector_boo<move_only_view<bidirectional_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_boo<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(other_ints);
+    test_vector_boo<move_only_view<random_access_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_boo<move_only_view<random_access_iterator_tag, test::Common::yes>>(other_ints);
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_vector(0, 0, some_ints, some_ints);
+    test_vector_boo(0, 0, other_ints, other_ints);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(from_range, some_ints);
+        test_vector(0, 0, vec, some_ints);
+    }
+    {
+        vector vec(from_range, other_ints);
+        test_vector_boo(0, 0, vec, other_ints);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(0, 0, lst, some_ints);
+    }
+    {
+        forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(0, 0, lst, other_ints);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_view();
+    STATIC_ASSERT(test_copyable_view());
+    test_move_only_view();
+    STATIC_ASSERT(test_move_only_view());
+
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<vector_instantiator, const int>();
+    test_in<vector_boo_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_vector_assign_range/env.lst b/tests/std/tests/P1206R7_vector_assign_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_assign_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_vector_assign_range/test.cpp b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
new file mode 100644
index 0000000000..e024dcac7d
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
@@ -0,0 +1,168 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector(const size_t presize, Rng&& rng, Expected&& expected) {
+    vector<int> vec(presize, -1);
+    vec.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(vec, expected));
+
+    return true;
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct vector_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector(0, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector(0, R{some_ints}, some_ints));
+
+        test_vector(5, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector(5, R{some_ints}, some_ints));
+
+        test_vector(11, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector(11, R{some_ints}, some_ints));
+    }
+};
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector_boo(const size_t presize, Rng&& rng, Expected&& expected) {
+    vector<bool> vec(presize, true);
+    vec.assign_range(forward<Rng>(rng));
+    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+
+    return true;
+}
+
+static constexpr int other_ints[80] = { //
+    0, 7, 0, 2, 3, 0, 0, 0, 4, 0, 0, 2, 5, 1, 0, 7, //
+    6, 3, 0, 7, 0, 5, 7, 0, 3, 4, 5, 0, 3, 0, 0, 2, //
+    2, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 5, 0, 0, 0, //
+    0, 4, 2, 4, 0, 7, 0, 2, 0, 7, 1, 0, 6, 0, 0, 6, //
+    3, 5, 0, 7, 0, 7, 0, 0, 2, 3, 5, 2, 2, 0, 7, 3};
+static constexpr auto first64_ints  = span{other_ints}.first<64>();
+
+struct vector_boo_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector_boo(0, R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_boo(0, R{other_ints}, other_ints));
+        test_vector_boo(40, R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_boo(40, R{other_ints}, other_ints));
+        test_vector_boo(ranges::size(other_ints), R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_boo(ranges::size(other_ints), R{other_ints}, other_ints));
+
+        test_vector_boo(0, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_boo(0, R{first64_ints}, first64_ints));
+        test_vector_boo(40, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_boo(40, R{first64_ints}, first64_ints));
+        test_vector_boo(64, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_boo(64, R{first64_ints}, first64_ints));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    {
+        constexpr span<const int> s{some_ints};
+        test_vector(0, s, some_ints);
+    }
+
+    {
+        constexpr span<const int> s{other_ints};
+        test_vector_boo(0, s, other_ints);
+    }
+
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    {
+        test_vector(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_vector(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_vector(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    }
+
+    {
+        test_vector_boo(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    }
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_vector(0, some_ints, some_ints);
+    test_vector_boo(0, other_ints, other_ints);
+
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(0, vec, some_ints);
+    }
+    {
+        vector vec(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(0, vec, other_ints);
+    }
+
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(0, lst, some_ints);
+    }
+    {
+        forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(0, lst, other_ints);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<vector_instantiator, const int>();
+    test_in<vector_boo_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_vector_from_range/env.lst b/tests/std/tests/P1206R7_vector_from_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_from_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_vector_from_range/test.cpp b/tests/std/tests/P1206R7_vector_from_range/test.cpp
new file mode 100644
index 0000000000..e1345880ef
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_from_range/test.cpp
@@ -0,0 +1,146 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector(Rng&& rng, Expected&& expected) {
+    vector<int> vec(from_range, forward<Rng>(rng));
+    assert(ranges::equal(vec, expected));
+
+    return true;
+}
+
+static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+struct vector_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector(R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector(R{some_ints}, some_ints));
+    }
+};
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector_boo(Rng&& rng, Expected&& expected) {
+    vector<bool> vec(from_range, forward<Rng>(rng));
+    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+
+    return true;
+}
+
+static constexpr int other_ints[80] = { //
+    0, 7, 0, 2, 3, 0, 0, 0, 4, 0, 0, 2, 5, 1, 0, 7, //
+    6, 3, 0, 7, 0, 5, 7, 0, 3, 4, 5, 0, 3, 0, 0, 2, //
+    2, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 5, 0, 0, 0, //
+    0, 4, 2, 4, 0, 7, 0, 2, 0, 7, 1, 0, 6, 0, 0, 6, //
+    3, 5, 0, 7, 0, 7, 0, 0, 2, 3, 5, 2, 2, 0, 7, 3};
+static constexpr auto first64_ints  = span{other_ints}.first<64>();
+
+struct vector_boo_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector_boo(R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_boo(R{other_ints}, other_ints));
+        test_vector_boo(R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_boo(R{first64_ints}, first64_ints));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    {
+        constexpr span<const int> s{some_ints};
+        test_vector(s, some_ints);
+    }
+    {
+        constexpr span<const int> s{other_ints};
+        test_vector_boo(s, other_ints);
+        test_vector_boo(first64_ints, first64_ints);
+    }
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    test_vector(move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_vector(move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_vector(move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_vector(move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_vector(move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    test_vector(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+    test_vector(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+
+    test_vector_boo(move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_boo(move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_vector(some_ints, some_ints);
+    test_vector_boo(other_ints, other_ints);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(vec, some_ints);
+    }
+    {
+        vector vec(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(vec, other_ints);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(lst, some_ints);
+    }
+    {
+        forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(lst, other_ints);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+
+    test_lvalue_forward_list();
+
+    test_in<vector_instantiator, const int>();
+    test_in<vector_boo_instantiator, const int>();
+}
diff --git a/tests/std/tests/P1206R7_vector_insert_range/env.lst b/tests/std/tests/P1206R7_vector_insert_range/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_insert_range/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1206R7_vector_insert_range/test.cpp b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
new file mode 100644
index 0000000000..5f9a0713e8
--- /dev/null
+++ b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
@@ -0,0 +1,166 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <forward_list>
+#include <ranges>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector(const size_t presize, Rng&& rng, Expected&& expected) {
+    vector<int> vec(presize, -1);
+    const same_as<vector<int>::iterator> auto result =
+        vec.insert_range(vec.begin() + (presize != 0), forward<Rng>(rng));
+    assert(result == vec.begin() + (presize != 0));
+    assert(ranges::equal(vec, expected));
+
+    return true;
+}
+
+static constexpr int some_ints[]    = {0, 1, 2, 3, 4, 5, 6, 7};
+static constexpr int short_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1}; // result of inserting some_ints at offset 1 in a sequence of 5 -1s
+static constexpr int long_result[] = {
+    -1, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // ditto, in a sequence of 11 -1s
+
+struct vector_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector(0, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector(0, R{some_ints}, some_ints));
+        test_vector(5, R{some_ints}, short_result);
+        STATIC_ASSERT(test_vector(5, R{some_ints}, short_result));
+        test_vector(11, R{some_ints}, long_result);
+        STATIC_ASSERT(test_vector(11, R{some_ints}, long_result));
+    }
+};
+
+template <ranges::input_range Rng, ranges::random_access_range Expected>
+constexpr bool test_vector_boo(const size_t presize, Rng&& rng, Expected&& expected) {
+    vector<bool> vec(presize, true);
+    const same_as<vector<bool>::iterator> auto result =
+        vec.insert_range(vec.begin() + (presize != 0), forward<Rng>(rng));
+    assert(result == vec.begin() + (presize != 0));
+    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+
+    return true;
+}
+
+static constexpr int other_ints[80]       = { //
+    0, 7, 0, 2, 3, 0, 0, 0, 4, 0, 0, 2, 5, 1, 0, 7, //
+    6, 3, 0, 7, 0, 5, 7, 0, 3, 4, 5, 0, 3, 0, 0, 2, //
+    2, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 5, 0, 0, 0, //
+    0, 4, 2, 4, 0, 7, 0, 2, 0, 7, 1, 0, 6, 0, 0, 6, //
+    3, 5, 0, 7, 0, 7, 0, 0, 2, 3, 5, 2, 2, 0, 7, 3};
+static constexpr int other_short_result[] = {true, false, true, true, true, true, true, true, true, true, true, true,
+    true}; // result of inserting other_ints at offset 1 in a sequence of 5 trues
+static constexpr int other_long_result[]  = {true, false, true, true, true, true, true, true, true, true, true, true,
+    true, true, true, true, true, true, true}; // ditto, in a sequence of 11 trues
+
+struct vector_boo_instantiator {
+    template <ranges::input_range R>
+    static void call() {
+        test_vector_boo(0, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector_boo(0, R{some_ints}, some_ints));
+        test_vector_boo(5, R{some_ints}, other_short_result);
+        STATIC_ASSERT(test_vector_boo(5, R{some_ints}, other_short_result));
+        test_vector_boo(11, R{some_ints}, other_long_result);
+        STATIC_ASSERT(test_vector_boo(11, R{some_ints}, other_long_result));
+    }
+};
+
+template <class Category, test::Common IsCommon, bool is_random = derived_from<Category, random_access_iterator_tag>>
+using move_only_view = test::range<Category, const int, test::Sized{is_random}, test::CanDifference{is_random},
+    IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
+    test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
+
+constexpr bool test_copyable_views() {
+    {
+        constexpr span<const int> s{some_ints};
+        test_vector(0, s, some_ints);
+    }
+    {
+        constexpr span<const int> s{other_ints};
+        test_vector_boo(0, s, other_ints);
+    }
+
+    return true;
+}
+
+constexpr bool test_move_only_views() {
+    {
+        test_vector(0, move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<forward_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<forward_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_vector(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+        test_vector(0, move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
+        test_vector(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
+    }
+    {
+        test_vector_boo(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    }
+
+    return true;
+}
+
+constexpr bool test_c_array() {
+    test_vector(0, some_ints, some_ints);
+    test_vector_boo(0, other_ints, other_ints);
+    return true;
+}
+
+constexpr bool test_lvalue_vector() {
+    {
+        vector vec(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(0, vec, some_ints);
+    }
+    {
+        vector vec(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(0, vec, other_ints);
+    }
+    return true;
+}
+
+void test_lvalue_forward_list() {
+    {
+        forward_list lst(ranges::begin(some_ints), ranges::end(some_ints));
+        test_vector(0, lst, some_ints);
+    }
+    {
+        forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
+        test_vector_boo(0, lst, other_ints);
+    }
+}
+
+int main() {
+    // Validate views
+    test_copyable_views();
+    STATIC_ASSERT(test_copyable_views());
+    test_move_only_views();
+    STATIC_ASSERT(test_move_only_views());
+
+    // Validate non-views
+    test_c_array();
+    STATIC_ASSERT(test_c_array());
+    test_lvalue_vector();
+    STATIC_ASSERT(test_lvalue_vector());
+    test_lvalue_forward_list();
+
+    test_in<vector_instantiator, const int>();
+    test_in<vector_boo_instantiator, const int>();
+}
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 34ca2d2adb..803f690e8c 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -634,6 +634,20 @@ STATIC_ASSERT(__cpp_lib_constexpr_vector == 201907L);
 #endif
 #endif
 
+#if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support and GH-1814
+#ifndef __cpp_lib_containers_ranges
+#error __cpp_lib_containers_ranges is not defined
+#elif __cpp_lib_containers_ranges != 202200L
+#error __cpp_lib_containers_ranges is not 202200L
+#else
+STATIC_ASSERT(__cpp_lib_containers_ranges == 202200L);
+#endif
+#else
+#ifdef __cpp_lib_containers_ranges
+#error __cpp_lib_containers_ranges is defined
+#endif
+#endif
+
 #ifdef __cpp_impl_coroutine
 #ifndef __cpp_lib_coroutine
 #error __cpp_lib_coroutine is not defined
@@ -1464,6 +1478,20 @@ STATIC_ASSERT(__cpp_lib_ranges_starts_ends_with == 202106L);
 #endif
 #endif
 
+#if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support and GH-1814
+#ifndef __cpp_lib_ranges_to_container
+#error __cpp_lib_ranges_to_container is not defined
+#elif __cpp_lib_ranges_to_container != 202200L
+#error __cpp_lib_ranges_to_container is not 202200L
+#else
+STATIC_ASSERT(__cpp_lib_ranges_to_container == 202200L);
+#endif
+#else
+#ifdef __cpp_lib_ranges_to_container
+#error __cpp_lib_ranges_to_container is defined
+#endif
+#endif
+
 #if _HAS_CXX17
 #ifndef __cpp_lib_raw_memory_algorithms
 #error __cpp_lib_raw_memory_algorithms is not defined

From a62fe8b97175dc70bd164c9f85a459c826490095 Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Mon, 20 Jun 2022 16:26:37 -0700
Subject: [PATCH 02/37] WIP

---
 stl/inc/xutility | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stl/inc/xutility b/stl/inc/xutility
index 2b24581604..84a85279a6 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -2403,7 +2403,7 @@ namespace ranges {
 
         constexpr explicit _Not_quite_object(_Construct_tag) noexcept {}
 
-        _Not_quite_object(const _Not_quite_object&) = delete;
+        _Not_quite_object(const _Not_quite_object&)            = delete;
         _Not_quite_object& operator=(const _Not_quite_object&) = delete;
 
         void operator&() const = delete;
@@ -3658,7 +3658,7 @@ _OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
     if constexpr (is_pointer_v<_OutCtgIt>) {
         return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Byte_count);
     } else {
-        return _Dest + _Count;
+        return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_Count);
     }
 }
 
@@ -5852,7 +5852,7 @@ public:
         return _Ret;
     }
 
-    _Rng_from_urng(const _Rng_from_urng&) = delete;
+    _Rng_from_urng(const _Rng_from_urng&)            = delete;
     _Rng_from_urng& operator=(const _Rng_from_urng&) = delete;
 
 private:

From 4e59216ada87ed1b797769eb55ad080a2ff90fca Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Tue, 21 Jun 2022 14:58:35 -0700
Subject: [PATCH 03/37] Fixes

---
 stl/inc/deque    | 13 ++++++++++---
 stl/inc/xtree    |  4 ++--
 stl/inc/xutility |  4 ++--
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index c2888863e8..a5e8d3f2a4 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1351,14 +1351,21 @@ public:
             _Orphan_all();
             if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
                 _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
-                for (; _UFirst != _ULast; ++_UFirst) {
-                    _Emplace_front_internal(*_UFirst); // prepend flipped
+                if constexpr (_Is_bidi_iter_v<_Iter>) {
+                    while (_UFirst != _ULast) {
+                        --_ULast;
+                        _Emplace_front_internal(*_ULast); // prepend in order
+                    }
+                } else {
+                    for (; _UFirst != _ULast; ++_UFirst) {
+                        _Emplace_front_internal(*_UFirst); // prepend flipped
+                    }
                 }
 
                 _Guard._Container = nullptr;
 
                 const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
-                if (!_Is_bidi_iter_v<_Iter>) {
+                if constexpr (!_Is_bidi_iter_v<_Iter>) {
                     _STD reverse(begin(), begin() + _Num); // flip new stuff in place
                 }
                 _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
diff --git a/stl/inc/xtree b/stl/inc/xtree
index a0da9d6f5f..5a2646a633 100644
--- a/stl/inc/xtree
+++ b/stl/inc/xtree
@@ -1253,9 +1253,9 @@ public:
 protected:
     template <class _Iter, class _Sent>
     void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
-        auto _Hint = _Get_scary()->_Myhead;
+        const auto _Myhead = _Get_scary()->_Myhead;
         for (; _First != _Last; ++_First) {
-            _Hint = _Emplace_hint(_Hint, *_First);
+            _Emplace_hint(_Myhead, *_First);
         }
     }
 
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 84a85279a6..c42ad23cda 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -2403,7 +2403,7 @@ namespace ranges {
 
         constexpr explicit _Not_quite_object(_Construct_tag) noexcept {}
 
-        _Not_quite_object(const _Not_quite_object&)            = delete;
+        _Not_quite_object(const _Not_quite_object&) = delete;
         _Not_quite_object& operator=(const _Not_quite_object&) = delete;
 
         void operator&() const = delete;
@@ -5852,7 +5852,7 @@ public:
         return _Ret;
     }
 
-    _Rng_from_urng(const _Rng_from_urng&)            = delete;
+    _Rng_from_urng(const _Rng_from_urng&) = delete;
     _Rng_from_urng& operator=(const _Rng_from_urng&) = delete;
 
 private:

From 2cb4fe9eebd375f312d58805b06a419ca76bed68 Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Tue, 21 Jun 2022 16:02:29 -0700
Subject: [PATCH 04/37] fix feature-test macro test

---
 .../test.compile.pass.cpp                            | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 803f690e8c..0b6be4212d 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -637,10 +637,10 @@ STATIC_ASSERT(__cpp_lib_constexpr_vector == 201907L);
 #if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support and GH-1814
 #ifndef __cpp_lib_containers_ranges
 #error __cpp_lib_containers_ranges is not defined
-#elif __cpp_lib_containers_ranges != 202200L
-#error __cpp_lib_containers_ranges is not 202200L
+#elif __cpp_lib_containers_ranges != 202202L
+#error __cpp_lib_containers_ranges is not 202202L
 #else
-STATIC_ASSERT(__cpp_lib_containers_ranges == 202200L);
+STATIC_ASSERT(__cpp_lib_containers_ranges == 202202L);
 #endif
 #else
 #ifdef __cpp_lib_containers_ranges
@@ -1481,10 +1481,10 @@ STATIC_ASSERT(__cpp_lib_ranges_starts_ends_with == 202106L);
 #if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support and GH-1814
 #ifndef __cpp_lib_ranges_to_container
 #error __cpp_lib_ranges_to_container is not defined
-#elif __cpp_lib_ranges_to_container != 202200L
-#error __cpp_lib_ranges_to_container is not 202200L
+#elif __cpp_lib_ranges_to_container != 202202L
+#error __cpp_lib_ranges_to_container is not 202202L
 #else
-STATIC_ASSERT(__cpp_lib_ranges_to_container == 202200L);
+STATIC_ASSERT(__cpp_lib_ranges_to_container == 202202L);
 #endif
 #else
 #ifdef __cpp_lib_ranges_to_container

From b5d02f456f1b38ca2a430c965dc6bcb1a4c89257 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Tue, 21 Jun 2022 21:18:02 -0700
Subject: [PATCH 05/37] frederick-vs-ja's deque comments

---
 stl/inc/deque | 160 ++++++++++++++++----------------------------------
 1 file changed, 52 insertions(+), 108 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index a5e8d3f2a4..8733048413 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -796,12 +796,12 @@ public:
         _Orphan_all();
 
         const auto _Oldsize = _Mysize();
-        _TRY_BEGIN
+        _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
         if constexpr (_RANGES bidirectional_range<_Rng>) {
             auto _ULast        = _RANGES _Get_final_iterator_unwrapped(_Range);
             const auto _UFirst = _RANGES _Ubegin(_Range);
             while (_UFirst != _ULast) {
-                _Emplace_front_internal(*--_ULast);
+                _Emplace_front_internal(*--_ULast); // prepend in order
             }
         } else {
             auto _UFirst      = _RANGES _Ubegin(_Range);
@@ -810,12 +810,7 @@ public:
                 _Emplace_front_internal(*_UFirst); // prepend flipped
             }
         }
-        _CATCH_ALL
-        while (_Oldsize < _Mysize()) {
-            pop_front(); // restore old size, at least
-        }
-        _RERAISE;
-        _CATCH_END
+        _Guard._Container = nullptr;
 
         if constexpr (!_RANGES bidirectional_range<_Rng>) {
             const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
@@ -837,16 +832,12 @@ public:
         const auto _Oldsize = _Mysize();
         auto _UFirst        = _RANGES _Ubegin(_Range);
         const auto _ULast   = _RANGES _Uend(_Range);
-        _TRY_BEGIN
+
+        _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
         for (; _UFirst != _ULast; ++_UFirst) {
             _Emplace_back_internal(*_UFirst);
         }
-        _CATCH_ALL
-        while (_Oldsize < _Mysize()) {
-            pop_back(); // restore old size, at least
-        }
-        _RERAISE;
-        _CATCH_END
+        _Guard._Container = nullptr;
     }
 #endif // __cpp_lib_containers_ranges
 
@@ -1331,120 +1322,73 @@ private:
         }
     };
 
-public:
-    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
-    iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
-        // insert [_First, _Last) at _Where, input iterators
-        size_type _Off = static_cast<size_type>(_Where - begin());
+    template <bool _Bidi, class _It, class _Se>
+    void _Insert_range(const size_type _Off, _It _First, _Se _Last) {
+        // insert [_First, _Last) at begin() + _Off
 
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
-        _Adl_verify_range(_First, _Last);
-        auto _UFirst = _Get_unwrapped(_First);
-        auto _ULast  = _Get_unwrapped(_Last);
-
-        size_type _Oldsize = _Mysize();
-
-        if (_UFirst != _ULast) {
-            _Orphan_all();
-            if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
-                _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
-                if constexpr (_Is_bidi_iter_v<_Iter>) {
-                    while (_UFirst != _ULast) {
-                        --_ULast;
-                        _Emplace_front_internal(*_ULast); // prepend in order
-                    }
-                } else {
-                    for (; _UFirst != _ULast; ++_UFirst) {
-                        _Emplace_front_internal(*_UFirst); // prepend flipped
-                    }
-                }
+        const size_type _Oldsize = _Mysize();
 
-                _Guard._Container = nullptr;
+        if (_First == _Last) {
+            return;
+        }
 
-                const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
-                if constexpr (!_Is_bidi_iter_v<_Iter>) {
-                    _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+        _Orphan_all();
+        if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
+            _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
+            if constexpr (_Bidi) {
+                while (_First != _Last) {
+                    _Emplace_front_internal(*--_Last); // prepend in order
                 }
-                _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
-            } else { // closer to back
-                _Orphan_all();
-                _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
-                for (; _UFirst != _ULast; ++_UFirst) {
-                    _Emplace_back_internal(*_UFirst);
+            } else {
+                for (; _First != _Last; ++_First) {
+                    _Emplace_front_internal(*_First); // prepend flipped
                 }
+            }
 
-                _Guard._Container = nullptr;
+            _Guard._Container = nullptr;
 
-                _STD rotate(begin() + static_cast<difference_type>(_Off),
-                    begin() + static_cast<difference_type>(_Oldsize), end());
+            const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
+            if constexpr (!_Bidi) {
+                _STD reverse(begin(), begin() + _Num); // flip new stuff in place
             }
+            _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
+            return;
         }
 
+        _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
+        for (; _First != _Last; ++_First) {
+            _Emplace_back_internal(*_First);
+        }
+
+        _Guard._Container = nullptr;
+
+        _STD rotate(
+            begin() + static_cast<difference_type>(_Off), begin() + static_cast<difference_type>(_Oldsize), end());
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        // insert [_First, _Last) at _Where, input iterators
+        _Adl_verify_range(_First, _Last);
+        const size_type _Off = static_cast<size_type>(_Where - begin());
+        _Insert_range<_Is_bidi_iter_v<_Iter>>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
         return begin() + static_cast<difference_type>(_Off);
     }
 
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
     iterator insert_range(const_iterator _Where, _Rng&& _Range) {
-        size_type _Off = static_cast<size_type>(_Where - begin());
+        const size_type _Off = static_cast<size_type>(_Where - begin());
 
-#if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
-#endif // _ITERATOR_DEBUG_LEVEL == 2
-
-        size_type _Oldsize = _Mysize();
-
-        auto _UFirst = _RANGES _Ubegin(_Range);
-        auto _ULast  = [&] {
-            if constexpr (_RANGES bidirectional_range<_Rng>) {
-                return _RANGES _Get_final_iterator_unwrapped(_Range);
-            } else {
-                return _RANGES _Uend(_Range);
-            }
-        }();
-        if (_UFirst != _ULast) {
-            _Orphan_all();
-            if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
-                _TRY_BEGIN
-                if constexpr (_RANGES bidirectional_range<_Rng>) {
-                    while (_UFirst != _ULast) {
-                        _Emplace_front_internal(*--_ULast);
-                    }
-                } else {
-                    for (; _UFirst != _ULast; ++_UFirst) {
-                        _Emplace_front_internal(*_UFirst); // prepend flipped
-                    }
-                }
-                _CATCH_ALL
-                while (_Oldsize < _Mysize()) {
-                    pop_front(); // restore old size, at least
-                }
-                _RERAISE;
-                _CATCH_END
-
-                const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
-                if constexpr (!_RANGES bidirectional_range<_Rng>) {
-                    _STD reverse(begin(), begin() + _Num); // flip new stuff in place
-                }
-                _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
-            } else { // closer to back
-                _TRY_BEGIN
-                for (; _UFirst != _ULast; ++_UFirst) {
-                    _Emplace_back_internal(*_UFirst);
-                }
-                _CATCH_ALL
-                while (_Oldsize < _Mysize()) {
-                    pop_back(); // restore old size, at least
-                }
-                _RERAISE;
-                _CATCH_END
-
-                _STD rotate(begin() + static_cast<difference_type>(_Off),
-                    begin() + static_cast<difference_type>(_Oldsize), end());
-            }
+        if constexpr (_RANGES bidirectional_range<_Rng>) {
+            _Insert_range<true>(_Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
+        } else {
+            _Insert_range<false>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
         }
 
         return begin() + static_cast<difference_type>(_Off);

From 5fae89bae458daaa86bb00031edc6b6dc1136b1e Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Tue, 21 Jun 2022 21:35:44 -0700
Subject: [PATCH 06/37] factor commonality from
 forward_list::insert_range_after and ::insert_after(pos, first, last)

---
 stl/inc/deque        | 17 ++++++++---------
 stl/inc/forward_list | 35 ++++++++++++++---------------------
 2 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index 8733048413..6d87595ad3 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1323,7 +1323,7 @@ private:
     };
 
     template <bool _Bidi, class _It, class _Se>
-    void _Insert_range(const size_type _Off, _It _First, _Se _Last) {
+    iterator _Insert_range(const size_type _Off, _It _First, _Se _Last) {
         // insert [_First, _Last) at begin() + _Off
 
 #if _ITERATOR_DEBUG_LEVEL == 2
@@ -1333,7 +1333,7 @@ private:
         const size_type _Oldsize = _Mysize();
 
         if (_First == _Last) {
-            return;
+            return begin() + static_cast<difference_type>(_Off);
         }
 
         _Orphan_all();
@@ -1356,7 +1356,7 @@ private:
                 _STD reverse(begin(), begin() + _Num); // flip new stuff in place
             }
             _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
-            return;
+            return begin() + static_cast<difference_type>(_Off);
         }
 
         _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
@@ -1368,6 +1368,8 @@ private:
 
         _STD rotate(
             begin() + static_cast<difference_type>(_Off), begin() + static_cast<difference_type>(_Oldsize), end());
+
+        return begin() + static_cast<difference_type>(_Off);
     }
 
 public:
@@ -1376,8 +1378,7 @@ public:
         // insert [_First, _Last) at _Where, input iterators
         _Adl_verify_range(_First, _Last);
         const size_type _Off = static_cast<size_type>(_Where - begin());
-        _Insert_range<_Is_bidi_iter_v<_Iter>>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
-        return begin() + static_cast<difference_type>(_Off);
+        return _Insert_range<_Is_bidi_iter_v<_Iter>>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
 #ifdef __cpp_lib_containers_ranges
@@ -1386,12 +1387,10 @@ public:
         const size_type _Off = static_cast<size_type>(_Where - begin());
 
         if constexpr (_RANGES bidirectional_range<_Rng>) {
-            _Insert_range<true>(_Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
+            return _Insert_range<true>(_Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
         } else {
-            _Insert_range<false>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+            return _Insert_range<false>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
         }
-
-        return begin() + static_cast<difference_type>(_Off);
     }
 #endif // __cpp_lib_containers_ranges
 
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index ce143ad6ee..21e4aabb46 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -997,43 +997,36 @@ public:
         return _Make_iter(_Where._Ptr);
     }
 
-    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
-    iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
+private:
+    template <class _It, class _Se>
+    iterator _Insert_range_after(const_iterator _Where, _It _First, const _Se _Last) {
         // insert [_First, _Last) after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(
             _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
-        _Adl_verify_range(_First, _Last);
-        const auto _UFirst = _Get_unwrapped(_First);
-        const auto _ULast  = _Get_unwrapped(_Last);
-        if (_UFirst == _ULast) {
+        if (_First == _Last) {
             return _Make_iter(_Where._Ptr);
         }
 
         _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
-        _Insert_op._Append_range_unchecked(_UFirst, _ULast);
+        _Insert_op._Append_range_unchecked(_STD move(_First), _Last);
         return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
     }
 
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
+        // insert [_First, _Last) after _Where
+        _Adl_verify_range(_First, _Last);
+        return _Insert_range_after(_Where, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+    }
+
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
     iterator insert_range_after(const_iterator _Where, _Rng&& _Range) {
-#if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(
-            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
-#endif // _ITERATOR_DEBUG_LEVEL == 2
-
-        auto _UFirst      = _RANGES _Ubegin(_Range);
-        const auto _ULast = _RANGES _Uend(_Range);
-        if (_UFirst == _ULast) {
-            return _Make_iter(_Where._Ptr);
-        }
-
-        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
-        _Insert_op._Append_range_unchecked(_STD move(_UFirst), _ULast);
-        return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
+        return _Insert_range_after(_Where, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
 #endif // __cpp_lib_containers_ranges
 

From 593e9a1bdbbbe9bf4eb443ed44037d66f7bdbc74 Mon Sep 17 00:00:00 2001
From: Casey Carter <cartec69@gmail.com>
Date: Tue, 21 Jun 2022 21:41:55 -0700
Subject: [PATCH 07/37] Fix inadvertent comment damage

---
 stl/inc/forward_list | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index 21e4aabb46..6dd12e3c00 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -463,7 +463,7 @@ struct _Flist_insert_after_op2 {
             ++_First; // throws
         }
 
-        while (_First != _Last) {
+        while (_First != _Last) { // throws
             _Newnode._Allocate(); // throws
             _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
             const auto _Newtail = _Newnode._Release();

From 3b687e87d469f7d840933a2e9970507353819828 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 24 Jun 2022 06:42:36 -0700
Subject: [PATCH 08/37] miscco's review comments

---
 stl/inc/deque                 | 53 +++++++++++++++++------------------
 stl/inc/forward_list          | 27 ++++++++++--------
 stl/inc/ranges                | 19 +++++++++----
 stl/inc/vector                | 45 ++++++++++++++---------------
 stl/inc/xstring               |  4 +--
 tests/libcxx/usual_matrix.lst |  2 +-
 6 files changed, 77 insertions(+), 73 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index 6d87595ad3..a36103cc32 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -809,13 +809,11 @@ public:
             for (; _UFirst != _ULast; ++_UFirst) {
                 _Emplace_front_internal(*_UFirst); // prepend flipped
             }
-        }
-        _Guard._Container = nullptr;
 
-        if constexpr (!_RANGES bidirectional_range<_Rng>) {
             const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
             _STD reverse(begin(), begin() + _Num); // flip new stuff in place
         }
+        _Guard._Container = nullptr;
     }
 #endif // __cpp_lib_containers_ranges
 
@@ -1170,8 +1168,8 @@ private:
             _Growmap(1);
         }
         _Myoff() &= _Mapsize() * _Block_size - 1;
-        size_type _Newoff = _Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size;
-        size_type _Block  = _Getblock(--_Newoff);
+        size_type _Newoff      = _Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size;
+        const size_type _Block = _Getblock(--_Newoff);
         if (_Map()[_Block] == nullptr) {
             _Map()[_Block] = _Getal().allocate(_Block_size);
         }
@@ -1219,26 +1217,20 @@ private:
         _Orphan_all();
         auto _Myfirst      = _Unchecked_begin();
         const auto _Mylast = _Unchecked_end();
-        for (;;) { // try to assign over an element in the container
+        // Reuse existing elements
+        for (; _Myfirst != _Mylast; ++_Myfirst, (void) ++_First) {
             if (_First == _Last) {
                 _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
                 return;
             }
 
-            if (_Myfirst == _Mylast) {
-                break;
-            }
-
             *_Myfirst = *_First;
-            ++_Myfirst;
-            ++_First;
         }
 
-        // container wasn't big enough, insert what's left at end
-        do {
+        // Allocate new elements for remaining tail of values
+        for (; _First != _Last; ++_First) {
             _Emplace_back_internal(*_First);
-            ++_First;
-        } while (_First != _Last);
+        }
     }
 
 public:
@@ -1322,7 +1314,9 @@ private:
         }
     };
 
-    template <bool _Bidi, class _It, class _Se>
+    enum class _Is_bidi : bool { _No, _Yes };
+
+    template <_Is_bidi _Bidi, class _It, class _Se>
     iterator _Insert_range(const size_type _Off, _It _First, _Se _Last) {
         // insert [_First, _Last) at begin() + _Off
 
@@ -1330,16 +1324,16 @@ private:
         _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
 
-        const size_type _Oldsize = _Mysize();
-
         if (_First == _Last) {
             return begin() + static_cast<difference_type>(_Off);
         }
 
+        const size_type _Oldsize = _Mysize();
+
         _Orphan_all();
-        if (_Off <= _Mysize() / 2) { // closer to front, push to front then rotate
+        if (_Off <= _Oldsize / 2) { // closer to front, push to front then rotate
             _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
-            if constexpr (_Bidi) {
+            if constexpr (_Bidi == _Is_bidi::_Yes) {
                 while (_First != _Last) {
                     _Emplace_front_internal(*--_Last); // prepend in order
                 }
@@ -1351,11 +1345,13 @@ private:
 
             _Guard._Container = nullptr;
 
-            const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
-            if constexpr (!_Bidi) {
-                _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+            const auto _Num     = static_cast<difference_type>(_Mysize() - _Oldsize);
+            const auto _Myfirst = _Unchecked_begin();
+            const auto _Mymid   = _Myfirst + _Num;
+            if constexpr (_Bidi == _Is_bidi::_No) {
+                _STD reverse(_Myfirst, _Mymid); // flip new stuff in place
             }
-            _STD rotate(begin(), begin() + _Num, begin() + _Num + static_cast<difference_type>(_Off));
+            _STD rotate(_Myfirst, _Mymid, _Mymid + static_cast<difference_type>(_Off));
             return begin() + static_cast<difference_type>(_Off);
         }
 
@@ -1378,7 +1374,7 @@ public:
         // insert [_First, _Last) at _Where, input iterators
         _Adl_verify_range(_First, _Last);
         const size_type _Off = static_cast<size_type>(_Where - begin());
-        return _Insert_range<_Is_bidi_iter_v<_Iter>>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+        return _Insert_range<_Is_bidi{_Is_bidi_iter_v<_Iter>}>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
 #ifdef __cpp_lib_containers_ranges
@@ -1387,9 +1383,10 @@ public:
         const size_type _Off = static_cast<size_type>(_Where - begin());
 
         if constexpr (_RANGES bidirectional_range<_Rng>) {
-            return _Insert_range<true>(_Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
+            return _Insert_range<_Is_bidi::_Yes>(
+                _Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
         } else {
-            return _Insert_range<false>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+            return _Insert_range<_Is_bidi::_No>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
         }
     }
 #endif // __cpp_lib_containers_ranges
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index 6dd12e3c00..54bc12af50 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -919,7 +919,7 @@ public:
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
     void prepend_range(_Rng&& _Range) {
-        insert_range_after(before_begin(), _Range);
+        _Insert_range_after(_Mypair._Myval2._Before_head(), _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
 #endif // __cpp_lib_containers_ranges
 
@@ -999,34 +999,37 @@ public:
 
 private:
     template <class _It, class _Se>
-    iterator _Insert_range_after(const_iterator _Where, _It _First, const _Se _Last) {
-        // insert [_First, _Last) after _Where
-#if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(
-            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
-#endif // _ITERATOR_DEBUG_LEVEL == 2
-
+    iterator _Insert_range_after(_Nodeptr _Pnode, _It _First, const _Se _Last) {
+        // insert [_First, _Last) after _Pnode
         if (_First == _Last) {
-            return _Make_iter(_Where._Ptr);
+            return _Make_iter(_Pnode);
         }
 
         _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
         _Insert_op._Append_range_unchecked(_STD move(_First), _Last);
-        return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
+        return _Make_iter(_Insert_op._Attach_after(_Pnode));
     }
 
 public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
         // insert [_First, _Last) after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list erase_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
         _Adl_verify_range(_First, _Last);
-        return _Insert_range_after(_Where, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+        return _Insert_range_after(_Where._Ptr, _Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
     iterator insert_range_after(const_iterator _Where, _Rng&& _Range) {
-        return _Insert_range_after(_Where, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list erase_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return _Insert_range_after(_Where._Ptr, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
 #endif // __cpp_lib_containers_ranges
 
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 99d573250a..e6ab76960d 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6367,17 +6367,24 @@ namespace ranges {
     concept _Common_constructible = common_range<_Rng> && _Cpp17_input_iterator<iterator_t<_Rng>>
         && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
 
+    template <class _Container, class _Reference>
+    concept _Can_push_back = requires(_Container& _Cont) {
+        _Cont.push_back(_STD declval<_Reference>());
+    };
+
+    template <class _Container, class _Reference>
+    concept _Can_insert_end = requires(_Container& _Cont) {
+        _Cont.insert(_Cont.end(), _STD declval<_Reference>());
+    };
+
     template <class _Rng, class _Container, class... _Types>
     concept _Constructible_and_insertable = constructible_from<_Container, _Types...>
-        && requires(_Container& _Cont) {
-            requires (
-                requires { _Cont.push_back(_STD declval<range_reference_t<_Rng>>()); }
-                || requires { _Cont.insert(_Cont.end(), _STD declval<range_reference_t<_Rng>>()); });
-        };
+        && (_Can_push_back<_Container, range_reference_t<_Rng>>
+            || _Can_insert_end<_Container, range_reference_t<_Rng>>);
 
     template <class _Reference, class _Container>
     _NODISCARD constexpr auto _Container_inserter(_Container& _Cont) {
-        if constexpr (requires { _Cont.push_back(_STD declval<_Reference>()); }) {
+        if constexpr (_Can_push_back<_Container, _Reference>) {
             return back_insert_iterator{_Cont};
         } else {
             return insert_iterator{_Cont, _Cont.end()};
diff --git a/stl/inc/vector b/stl/inc/vector
index 00ad8cac29..ccdf222cbe 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -695,7 +695,8 @@ public:
         auto _UFirst = _Get_unwrapped(_First);
         auto _ULast  = _Get_unwrapped(_Last);
         if constexpr (_Is_fwd_iter_v<_Iter>) {
-            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_UFirst, _ULast)));
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
             _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
 #ifdef __cpp_lib_concepts
         } else if constexpr (forward_iterator<_Iter>) {
@@ -1307,7 +1308,8 @@ public:
         auto _ULast          = _Get_unwrapped(_Last);
         const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
         if constexpr (_Is_fwd_iter_v<_Iter>) {
-            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_UFirst, _ULast)));
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
             _Insert_counted_range(_Where, _UFirst, _Count);
 #ifdef __cpp_lib_concepts
         } else if constexpr (forward_iterator<_Iter>) {
@@ -1462,30 +1464,24 @@ private:
 
         const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
         if (_Newsize > _Oldsize) {
+            bool _Copied = false;
+            if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {
 #if _HAS_CXX20
-            constexpr
-#endif // _HAS_CXX20
-                auto _Copy_n_helper = [](_Iter _In, size_type _Count, pointer _Out) {
-                    // copy _In + [0, _Count) to _Out, returning _In + _Count
-                    // (This is _Copy_n_unchecked, except it returns _In instead of _Out.)
-                    if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {
-#if _HAS_CXX20
-                        if (!_STD is_constant_evaluated())
+                if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
-                        {
-                            _Copy_memmove_n(_In, _Count, _Out);
-                            return _In + _Count;
-                        }
-                    }
-
-                    for (; _Count != 0; ++_Out, (void) ++_In, --_Count) {
-                        *_Out = *_In;
-                    }
+                {
+                    _Copy_memmove_n(_First, _Oldsize, _Myfirst);
+                    _First += _Oldsize;
+                    _Copied = true;
+                }
+            }
 
-                    return _In;
-                };
+            if (!_Copied) {
+                for (auto _Mid = _Myfirst; _Mid != _Mylast; ++_Mid, (void) ++_First) {
+                    *_Mid = *_First;
+                }
+            }
 
-            _First = _Copy_n_helper(_STD move(_First), _Oldsize, _Myfirst);
             if constexpr (_Nothrow_construct) {
                 _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
                 _Mylast = _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
@@ -3406,8 +3402,9 @@ public:
         const auto _ULast = _Get_unwrapped(_Last);
 
         if constexpr (_Is_fwd_iter_v<_Iter>) {
-            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_UFirst, _ULast)));
-            const auto _Off   = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
             _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
         } else {
             difference_type _Off = _Saved_offset;
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 5d0323b8c8..5ab0670f53 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2826,8 +2826,8 @@ public:
         if constexpr (_RANGES sized_range<_Rng>) {
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
 
-            if constexpr (contiguous_iterator<decltype(_RANGES _Ubegin(
-                              _Range))> && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+            if constexpr (contiguous_iterator<decltype(_RANGES _Ubegin(_Range))> && //
+                same_as<_RANGES range_value_t<_Rng>, _Elem>) {
                 if (_Count != 0) {
                     const auto _Ptr = _STD to_address(_RANGES _Ubegin(_Range));
                     assign(_Ptr, _Count);
diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst
index c0de4d15f8..aaaf2ecf6b 100644
--- a/tests/libcxx/usual_matrix.lst
+++ b/tests/libcxx/usual_matrix.lst
@@ -4,7 +4,7 @@
 RUNALL_INCLUDE ..\universal_prefix.lst
 RUNALL_CROSSLIST
 # TRANSITION, LLVM-53957: _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS belongs to llvm-project/libcxx/test/support/msvc_stdlib_force_include.h
-PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER /D_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS /D_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING /D_USE_JOIN_VIEW_INPUT_RANGE"
+PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER /D_USE_JOIN_VIEW_INPUT_RANGE"
 RUNALL_CROSSLIST
 PM_CL="/analyze:autolog- /Zc:preprocessor"
 PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing"

From ccf85f43537a8241a8f70deb7ed4f9322d777484 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 24 Jun 2022 11:55:29 -0700
Subject: [PATCH 09/37] STL's review comments

---
 stl/inc/list     |  1 +
 stl/inc/vector   |  2 +-
 stl/inc/xutility | 28 ++++++++++++----------------
 3 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/stl/inc/list b/stl/inc/list
index 3019a625f2..74ea28e6ca 100644
--- a/stl/inc/list
+++ b/stl/inc/list
@@ -1328,6 +1328,7 @@ private:
 public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     void assign(_Iter _First, _Iter _Last) {
+        _Adl_verify_range(_First, _Last);
         _Assign_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
diff --git a/stl/inc/vector b/stl/inc/vector
index ccdf222cbe..ac82c2e708 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -1470,7 +1470,7 @@ private:
                 if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
                 {
-                    _Copy_memmove_n(_First, _Oldsize, _Myfirst);
+                    _Copy_memmove_n(_First, static_cast<size_t>(_Oldsize), _Myfirst);
                     _First += _Oldsize;
                     _Copied = true;
                 }
diff --git a/stl/inc/xutility b/stl/inc/xutility
index c42ad23cda..37759dc2ef 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -3649,15 +3649,10 @@ _OutCtgIt _Copy_memmove(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
 
 template <class _CtgIt, class _OutCtgIt>
 _OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
-    auto _FirstPtr              = _To_address(_First);
-    auto _DestPtr               = _To_address(_Dest);
-    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
-    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
-    const auto _Byte_count      = _Count * sizeof(*_FirstPtr);
-    _CSTD memmove(_Dest_ch, _First_ch, _Byte_count);
+    const auto _Result = _Copy_memmove(_First, _First + _Count, _Dest);
     if constexpr (is_pointer_v<_OutCtgIt>) {
-        return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Byte_count);
-    } else {
+        return _Result;
+    } else { // _Result is unused so the compiler can optimize it away
         return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_Count);
     }
 }
@@ -3665,16 +3660,20 @@ _OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
 template <class _It, bool _RequiresMutable = false>
 _INLINE_VAR constexpr bool _Is_vb_iterator = false;
 
-template <class _InIt, class _OutIt>
-_CONSTEXPR20 _OutIt _Copy_n_unchecked(_InIt _First, size_t _Count, _OutIt _Dest) {
+template <class _InIt, class _SizeTy, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_n_unchecked(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
     // copy _First + [0, _Count) to _Dest + [0, _Count), returning _Dest + _Count
     // note: has callers outside the copy family
+#ifdef __cpp_lib_concepts
+    _STL_INTERNAL_STATIC_ASSERT(_Integer_like<_SizeTy>);
+#endif // __cpp_lib_concepts
+
     if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            return _Copy_memmove_n(_First, _Count, _Dest);
+            return _Copy_memmove_n(_First, static_cast<size_t>(_Count), _Dest);
         }
     }
 
@@ -3705,15 +3704,12 @@ _CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
         {
 #ifdef __cpp_lib_concepts
             if constexpr (is_same_v<_InIt, _Sent>)
-#else // ^^^ Concepts support / no Concepts vvv
-            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_InIt, _Sent>);
 #endif // __cpp_lib_concepts
             {
                 return _Copy_memmove(_First, _Last, _Dest);
             }
 #ifdef __cpp_lib_concepts
             else {
-                _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Sent, _InIt>);
                 return _Copy_memmove_n(_First, static_cast<size_t>(_Last - _First), _Dest);
             }
 #endif // __cpp_lib_concepts
@@ -3852,8 +3848,8 @@ namespace ranges {
                     return {_STD move(_Last), _STD move(_Result)};
                 } else {
                     _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Se, _It>);
-                    auto _Count = static_cast<size_t>(_Last - _First);
-                    _Result     = _Copy_memmove_n(_First, _Count, _STD move(_Result));
+                    const auto _Count = static_cast<size_t>(_Last - _First);
+                    _Result           = _Copy_memmove_n(_First, _Count, _STD move(_Result));
                     _First += _Count;
                     return {_STD move(_First), _STD move(_Result)};
                 }

From b2a02622c1ae39f440310756bc00ee6a478332d9 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 24 Jun 2022 12:04:03 -0700
Subject: [PATCH 10/37] Consistently use `_Iter, _Sent` in container code

---
 stl/inc/deque        |  4 ++--
 stl/inc/forward_list |  4 ++--
 stl/inc/xstring      | 12 ++++++------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index a36103cc32..a9dabf5f0c 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1316,8 +1316,8 @@ private:
 
     enum class _Is_bidi : bool { _No, _Yes };
 
-    template <_Is_bidi _Bidi, class _It, class _Se>
-    iterator _Insert_range(const size_type _Off, _It _First, _Se _Last) {
+    template <_Is_bidi _Bidi, class _Iter, class _Sent>
+    iterator _Insert_range(const size_type _Off, _Iter _First, _Sent _Last) {
         // insert [_First, _Last) at begin() + _Off
 
 #if _ITERATOR_DEBUG_LEVEL == 2
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index 54bc12af50..0af751b1b1 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -998,8 +998,8 @@ public:
     }
 
 private:
-    template <class _It, class _Se>
-    iterator _Insert_range_after(_Nodeptr _Pnode, _It _First, const _Se _Last) {
+    template <class _Iter, class _Sent>
+    iterator _Insert_range_after(_Nodeptr _Pnode, _Iter _First, const _Sent _Last) {
         // insert [_First, _Last) after _Pnode
         if (_First == _Last) {
             return _Make_iter(_Pnode);
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 5ab0670f53..7eebef24e5 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -1240,9 +1240,9 @@ public:
 
 #ifdef __cpp_lib_concepts
     // clang-format off
-    template <contiguous_iterator _It, sized_sentinel_for<_It> _Se>
-        requires (is_same_v<iter_value_t<_It>, _Elem> && !is_convertible_v<_Se, size_type>)
-    constexpr basic_string_view(_It _First, _Se _Last) noexcept(noexcept(_Last - _First)) // strengthened
+    template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
+        requires (is_same_v<iter_value_t<_Iter>, _Elem> && !is_convertible_v<_Sent, size_type>)
+    constexpr basic_string_view(_Iter _First, _Sent _Last) noexcept(noexcept(_Last - _First)) // strengthened
         : _Mydata(_STD to_address(_First)), _Mysize(static_cast<size_type>(_Last - _First)) {}
     // clang-format on
 
@@ -1657,8 +1657,8 @@ private:
 };
 
 #ifdef __cpp_lib_concepts
-template <contiguous_iterator _It, sized_sentinel_for<_It> _Se>
-basic_string_view(_It, _Se) -> basic_string_view<iter_value_t<_It>>;
+template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
+basic_string_view(_Iter, _Sent) -> basic_string_view<iter_value_t<_Iter>>;
 
 #if _HAS_CXX23
 template <_RANGES contiguous_range _Range>
@@ -2827,7 +2827,7 @@ public:
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
 
             if constexpr (contiguous_iterator<decltype(_RANGES _Ubegin(_Range))> && //
-                same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+                          same_as<_RANGES range_value_t<_Rng>, _Elem>) {
                 if (_Count != 0) {
                     const auto _Ptr = _STD to_address(_RANGES _Ubegin(_Range));
                     assign(_Ptr, _Count);

From e75816a9f38f10582ee29cdaf7401df1caec5a61 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 24 Jun 2022 12:59:12 -0700
Subject: [PATCH 11/37] Revert accidental change to libcxx/usual_matrix.lst

---
 tests/libcxx/usual_matrix.lst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst
index aaaf2ecf6b..c0de4d15f8 100644
--- a/tests/libcxx/usual_matrix.lst
+++ b/tests/libcxx/usual_matrix.lst
@@ -4,7 +4,7 @@
 RUNALL_INCLUDE ..\universal_prefix.lst
 RUNALL_CROSSLIST
 # TRANSITION, LLVM-53957: _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS belongs to llvm-project/libcxx/test/support/msvc_stdlib_force_include.h
-PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER /D_USE_JOIN_VIEW_INPUT_RANGE"
+PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER /D_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS /D_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING /D_USE_JOIN_VIEW_INPUT_RANGE"
 RUNALL_CROSSLIST
 PM_CL="/analyze:autolog- /Zc:preprocessor"
 PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing"

From 3e6b68fccb9db66d8d7dbfc20688ff7247078b52 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 24 Jun 2022 13:02:53 -0700
Subject: [PATCH 12/37] enum_class{underlying_value} is C++17

---
 stl/inc/deque | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index a9dabf5f0c..480241d1ee 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1374,7 +1374,8 @@ public:
         // insert [_First, _Last) at _Where, input iterators
         _Adl_verify_range(_First, _Last);
         const size_type _Off = static_cast<size_type>(_Where - begin());
-        return _Insert_range<_Is_bidi{_Is_bidi_iter_v<_Iter>}>(_Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
+        return _Insert_range<static_cast<_Is_bidi>(_Is_bidi_iter_v<_Iter>)>(
+            _Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
 #ifdef __cpp_lib_containers_ranges

From 29feac1ae0e8d98dc69826f712a386ef047b4dd3 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Mon, 27 Jun 2022 12:21:10 -0700
Subject: [PATCH 13/37] cpplearner's comment; Update LWG issue number

---
 stl/inc/queue  | 2 +-
 stl/inc/vector | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/stl/inc/queue b/stl/inc/queue
index 81ee00bf4b..c83a66d595 100644
--- a/stl/inc/queue
+++ b/stl/inc/queue
@@ -377,7 +377,7 @@ public:
 
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
-    void push_range(_Rng&& _Range) { // LWG issue submitted but unnumbered as of 2022-06-20
+    void push_range(_Rng&& _Range) { // per LWG-3723
         if constexpr (requires { c.append_range(_Range); }) {
             c.append_range(_Range);
         } else {
diff --git a/stl/inc/vector b/stl/inc/vector
index ac82c2e708..be0bad7f96 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -1506,8 +1506,7 @@ public:
         auto _UFirst = _Get_unwrapped(_First);
         auto _ULast  = _Get_unwrapped(_Last);
         if constexpr (_Is_fwd_iter_v<_Iter>) {
-            using _SizeTy      = make_unsigned_t<typename iterator_traits<_Iter>::difference_type>;
-            const auto _Length = static_cast<_SizeTy>(_STD distance(_UFirst, _ULast));
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
             const auto _Count  = _Convert_size<size_type>(_Length);
             _Assign_counted_range(_UFirst, _Count);
 #ifdef __cpp_lib_concepts

From 073cc1a8d117c221fb54a61ce82cf029d707bcda Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Fri, 22 Jul 2022 21:40:35 -0700
Subject: [PATCH 14/37] Review comments

---
 stl/inc/deque        |  11 +++--
 stl/inc/forward_list |  13 ++---
 stl/inc/list         |   2 +-
 stl/inc/ranges       |  70 ++++++++++++++++-----------
 stl/inc/vector       |  16 ++----
 stl/inc/xmemory      |  35 ++++++--------
 stl/inc/xstring      | 113 ++++++++++++++-----------------------------
 stl/inc/xutility     |   9 ++--
 8 files changed, 117 insertions(+), 152 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index 480241d1ee..a8cead482e 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -811,7 +811,7 @@ public:
             }
 
             const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
-            _STD reverse(begin(), begin() + _Num); // flip new stuff in place
+            _STD reverse(begin(), begin() + _Num); // Per LWG-3742
         }
         _Guard._Container = nullptr;
     }
@@ -1319,6 +1319,8 @@ private:
     template <_Is_bidi _Bidi, class _Iter, class _Sent>
     iterator _Insert_range(const size_type _Off, _Iter _First, _Sent _Last) {
         // insert [_First, _Last) at begin() + _Off
+        // Pre: _Bidi == _Is_bidi::_Yes implies that _Iter and _Sent are the same type, and that
+        //      _Iter is either a bidirectional_iterator or a Cpp17BidirectionalIterator.
 
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
@@ -1362,8 +1364,9 @@ private:
 
         _Guard._Container = nullptr;
 
-        _STD rotate(
-            begin() + static_cast<difference_type>(_Off), begin() + static_cast<difference_type>(_Oldsize), end());
+        const auto _Myfirst = _Unchecked_begin();
+        _STD rotate(_Myfirst + static_cast<difference_type>(_Off), _Myfirst + static_cast<difference_type>(_Oldsize),
+            _Unchecked_end());
 
         return begin() + static_cast<difference_type>(_Off);
     }
@@ -1371,7 +1374,7 @@ private:
 public:
     template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
     iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
-        // insert [_First, _Last) at _Where, input iterators
+        // insert [_First, _Last) at _Where
         _Adl_verify_range(_First, _Last);
         const size_type _Off = static_cast<size_type>(_Where - begin());
         return _Insert_range<static_cast<_Is_bidi>(_Is_bidi_iter_v<_Iter>)>(
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index 0af751b1b1..204a4fc3ac 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -708,7 +708,7 @@ public:
     iterator emplace_after(const_iterator _Where, _Valty&&... _Val) { // insert element after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(
-            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after iterator outside range");
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list emplace_after iterator outside range");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
         _Insert_after(_Where._Ptr, _STD forward<_Valty>(_Val)...);
         return _Make_iter(_Where._Ptr->_Next);
@@ -975,7 +975,8 @@ public:
 
     iterator insert_after(const_iterator _Where, const _Ty& _Val) { // insert _Val after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "insert_after location incompatible");
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
         _Insert_after(_Where._Ptr, _Val);
         return _Make_iter(_Where._Ptr->_Next);
@@ -1016,7 +1017,7 @@ public:
         // insert [_First, _Last) after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
         _STL_VERIFY(
-            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list erase_after iterator outside range");
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
         _Adl_verify_range(_First, _Last);
         return _Insert_range_after(_Where._Ptr, _Get_unwrapped(_First), _Get_unwrapped(_Last));
@@ -1026,8 +1027,8 @@ public:
     template <_Container_compatible_range<_Ty> _Rng>
     iterator insert_range_after(const_iterator _Where, _Rng&& _Range) {
 #if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(
-            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list erase_after iterator outside range");
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2),
+            "forward_list insert_range_after location incompatible");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
         return _Insert_range_after(_Where._Ptr, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
     }
@@ -1293,7 +1294,7 @@ private:
 #if _ITERATOR_DEBUG_LEVEL != 0
         _DEBUG_ORDER_UNWRAPPED(_Right._Unchecked_begin(), _Default_sentinel{}, _Pred);
         if constexpr (!_Alnode_traits::is_always_equal::value) {
-            _STL_VERIFY(_Getal() == _Right._Getal(), "list allocators incompatible for merge");
+            _STL_VERIFY(_Getal() == _Right._Getal(), "forward_list allocators incompatible for merge");
         }
 #endif // _ITERATOR_DEBUG_LEVEL != 0
 
diff --git a/stl/inc/list b/stl/inc/list
index 74ea28e6ca..106259392f 100644
--- a/stl/inc/list
+++ b/stl/inc/list
@@ -1395,7 +1395,7 @@ public:
     template <_Container_compatible_range<_Ty> _Rng>
     iterator insert_range(const_iterator _Where, _Rng&& _Range) {
 #if _ITERATOR_DEBUG_LEVEL == 2
-        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert_range iterator outside range");
 #endif // _ITERATOR_DEBUG_LEVEL == 2
         _List_node_insert_op2<_Alnode> _Op(_Getal());
         _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
diff --git a/stl/inc/ranges b/stl/inc/ranges
index e6ab76960d..3507bd87f3 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -231,7 +231,7 @@ namespace ranges {
         ~_Cached_position() = default;
 
         // Offsets are oblivious to copying, so cache values _do_ propagate via copying.
-        _Cached_position(const _Cached_position&) = default;
+        _Cached_position(const _Cached_position&)            = default;
         _Cached_position& operator=(const _Cached_position&) = default;
 
         // Offsets are potentially invalidated by move, so source caches are invalidated after move
@@ -1358,7 +1358,7 @@ namespace ranges {
             _Iterator(_Iterator&&)      = default;
 
             _Iterator& operator=(const _Iterator&) = delete;
-            _Iterator& operator=(_Iterator&&) = default;
+            _Iterator& operator=(_Iterator&&)      = default;
 
             _Iterator& operator++() {
 #if _ITERATOR_DEBUG_LEVEL != 0
@@ -1503,7 +1503,7 @@ namespace ranges {
         constexpr owning_view(_Rng&& _Range_) noexcept(is_nothrow_move_constructible_v<_Rng>) // strengthened
             : _Range(_STD move(_Range_)) {}
 
-        owning_view(owning_view&&) = default;
+        owning_view(owning_view&&)            = default;
         owning_view& operator=(owning_view&&) = default;
 
         _NODISCARD constexpr _Rng& base() & noexcept {
@@ -5275,7 +5275,7 @@ namespace ranges {
             using difference_type  = range_difference_t<_Vw>;
             using value_type       = range_value_t<_Vw>;
 
-            _Inner_iterator(_Inner_iterator&&) = default;
+            _Inner_iterator(_Inner_iterator&&)            = default;
             _Inner_iterator& operator=(_Inner_iterator&&) = default;
 
             _NODISCARD constexpr const iterator_t<_Vw>& base() const& noexcept /* strengthened */ {
@@ -5384,7 +5384,7 @@ namespace ranges {
                 }
             };
 
-            _Outer_iterator(_Outer_iterator&&) = default;
+            _Outer_iterator(_Outer_iterator&&)            = default;
             _Outer_iterator& operator=(_Outer_iterator&&) = default;
 
             _NODISCARD constexpr value_type operator*() const noexcept /* strengthened */ {
@@ -6357,14 +6357,26 @@ namespace ranges {
     // clang-format off
     template <class _Range, class _Container>
     concept _Sized_and_reservable = sized_range<_Range> && sized_range<_Container>
-        && requires(_Container& _Cont, const _Container& _CCont, const range_size_t<_Container> _Count) {
+        && requires(_Container& _Cont, const range_size_t<_Container> _Count) {
             _Cont.reserve(_Count);
-            { _CCont.capacity() } -> same_as<range_size_t<_Container>>;
-            { _CCont.max_size() } -> same_as<range_size_t<_Container>>;
+            { _Cont.capacity() } -> same_as<range_size_t<_Container>>;
+            { _Cont.max_size() } -> same_as<range_size_t<_Container>>;
         };
 
+    template <class _Rng, class _Container>
+    concept _Ref_converts = convertible_to<range_reference_t<_Rng>, range_value_t<_Container>>;
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Converts_direct_constructible = _Ref_converts<_Rng, _Container>
+        && constructible_from<_Container, _Rng, _Types...>;
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Converts_tag_constructible = _Ref_converts<_Rng, _Container>
+        && constructible_from<_Container, from_range_t, _Rng, _Types...>;
+
     template <class _Rng, class _Container, class... _Types>
-    concept _Common_constructible = common_range<_Rng> && _Cpp17_input_iterator<iterator_t<_Rng>>
+    concept _Converts_and_common_constructible = _Ref_converts<_Rng, _Container> && common_range<_Rng>
+        && _Cpp17_input_iterator<iterator_t<_Rng>>
         && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
 
     template <class _Container, class _Reference>
@@ -6378,7 +6390,8 @@ namespace ranges {
     };
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Constructible_and_insertable = constructible_from<_Container, _Types...>
+    concept _Converts_constructible_insertable = _Ref_converts<_Rng, _Container>
+        && constructible_from<_Container, _Types...>
         && (_Can_push_back<_Container, range_reference_t<_Rng>>
             || _Can_insert_end<_Container, range_reference_t<_Rng>>);
 
@@ -6395,14 +6408,13 @@ namespace ranges {
         requires (!view<_Container>)
     _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {
         // clang-format on
-        constexpr bool _Ref_converts = convertible_to<range_reference_t<_Rng>, range_value_t<_Container>>;
-        if constexpr (_Ref_converts && constructible_from<_Container, _Rng, _Types...>) {
+        if constexpr (_Converts_direct_constructible<_Rng, _Container, _Types...>) {
             return _Container(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
-        } else if constexpr (_Ref_converts && constructible_from<_Container, from_range_t, _Rng, _Types...>) {
+        } else if constexpr (_Converts_tag_constructible<_Rng, _Container, _Types...>) {
             return _Container(from_range, _STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
-        } else if constexpr (_Ref_converts && _Common_constructible<_Rng, _Container, _Types...>) {
+        } else if constexpr (_Converts_and_common_constructible<_Rng, _Container, _Types...>) {
             return _Container(_RANGES begin(_Range), _RANGES end(_Range), _STD forward<_Types...>(_Args)...);
-        } else if constexpr (_Ref_converts && _Constructible_and_insertable<_Rng, _Container, _Types...>) {
+        } else if constexpr (_Converts_constructible_insertable<_Rng, _Container, _Types...>) {
             _Container _Cont(_STD forward<_Types>(_Args)...);
             if constexpr (_Sized_and_reservable<_Rng, _Container>) {
                 _Cont.reserve(_RANGES size(_Range));
@@ -6455,19 +6467,23 @@ namespace ranges {
         bool operator==(const _Phony_input_iterator&) const;
     };
 
-    template <template <class...> class _Container, class _Rng, class... _Types>
-    auto _To_helper(int) -> decltype(_Container(_STD declval<_Rng>(), _STD declval<_Types>()...)); // not defined
-
-    template <template <class...> class _Container, class _Rng, class... _Types>
-    auto _To_helper(long)
-        -> decltype(_Container(from_range, _STD declval<_Rng>(), _STD declval<_Types>()...)); // not defined
-
-    template <template <class...> class _Container, class _Rng, class... _Types>
-    auto _To_helper(...) -> decltype(_Container(_STD declval<_Phony_input_iterator<_Rng>>(),
-        _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Types>()...)); // not defined
+    template <template <class...> class _Cnt, class _Rng, class... _Args>
+    auto _To_helper() {
+        if constexpr (requires { _Cnt(std::declval<_Rng>(), std::declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(std::declval<_Rng>(), std::declval<_Args>()...))*>(nullptr);
+        } else if constexpr (requires { _Cnt(from_range, std::declval<_Rng>(), std::declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(from_range, std::declval<_Rng>(), std::declval<_Args>()...))*>(nullptr);
+        } else if constexpr (requires {
+                                 _Cnt(std::declval<_Phony_input_iterator<_Rng>>(),
+                                     std::declval<_Phony_input_iterator<_Rng>>(), std::declval<_Args>()...);
+                             }) {
+            return static_cast<decltype(_Cnt(std::declval<_Phony_input_iterator<_Rng>>(),
+                std::declval<_Phony_input_iterator<_Rng>>(), std::declval<_Args>()...))*>(nullptr);
+        }
+    }
 
     template <template <class...> class _Container, input_range _Rng, class... _Types,
-        class _Deduced = decltype(_To_helper<_Container, _Rng, _Types...>(42))>
+        class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
     _NODISCARD constexpr _Deduced to(_Rng&& _Range, _Types&&... _Args) {
         return to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
     }
@@ -6475,7 +6491,7 @@ namespace ranges {
     template <template <class...> class _Container>
     struct _To_template_fn {
         template <input_range _Rng, class... _Types,
-            class _Deduced = decltype(_To_helper<_Container, _Rng, _Types...>(42))>
+            class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
         _NODISCARD constexpr auto operator()(_Rng&& _Range, _Types&&... _Args) const {
             return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
         }
diff --git a/stl/inc/vector b/stl/inc/vector
index be0bad7f96..ee086a697d 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -602,7 +602,7 @@ private:
 
     class _NODISCARD _Asan_extend_guard {
     public:
-        _Asan_extend_guard(const _Asan_extend_guard&) = delete;
+        _Asan_extend_guard(const _Asan_extend_guard&)            = delete;
         _Asan_extend_guard& operator=(const _Asan_extend_guard&) = delete;
 
         constexpr explicit _Asan_extend_guard(vector* _Myvec_, size_type _Target_size_) noexcept
@@ -633,7 +633,7 @@ private:
 
     class _NODISCARD _Asan_create_guard {
     public:
-        _Asan_create_guard(const _Asan_create_guard&) = delete;
+        _Asan_create_guard(const _Asan_create_guard&)            = delete;
         _Asan_create_guard& operator=(const _Asan_create_guard&) = delete;
 
         constexpr explicit _Asan_create_guard(const vector& _Myvec_) noexcept : _Myvec(_Myvec_) {}
@@ -709,10 +709,7 @@ public:
             _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
             _Tidy_guard<vector> _Guard{this};
 
-            for (; _UFirst != _ULast; ++_UFirst) {
-                // performance note: _Emplace_one_at_back's strong guarantee is unnecessary here.
-                _Emplace_one_at_back(*_UFirst);
-            }
+            _Append_uncounted_range(_STD move(_UFirst), _STD move(_ULast));
 
             _Guard._Target = nullptr;
             _Proxy._Release();
@@ -737,12 +734,7 @@ public:
             _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
             _Tidy_guard<vector> _Guard{this};
 
-            auto _UFirst      = _RANGES _Ubegin(_Range);
-            const auto _ULast = _RANGES _Uend(_Range);
-            for (; _UFirst != _ULast; ++_UFirst) {
-                // performance note: _Emplace_one_at_back's strong guarantee is unnecessary here.
-                _Emplace_one_at_back(*_UFirst);
-            }
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
 
             _Guard._Target = nullptr;
             _Proxy._Release();
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index be2c5f2cb4..537f05e8b4 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -823,7 +823,7 @@ public:
     constexpr allocator(const allocator&) noexcept = default;
     template <class _Other>
     constexpr allocator(const allocator<_Other>&) noexcept {}
-    _CONSTEXPR20 ~allocator()       = default;
+    _CONSTEXPR20 ~allocator()                           = default;
     _CONSTEXPR20 allocator& operator=(const allocator&) = default;
 
     _CONSTEXPR20 void deallocate(_Ty* const _Ptr, const size_t _Count) {
@@ -1020,7 +1020,7 @@ struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_
         }
     }
 
-    _Alloc_construct_ptr(const _Alloc_construct_ptr&) = delete;
+    _Alloc_construct_ptr(const _Alloc_construct_ptr&)            = delete;
     _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete;
 };
 
@@ -1055,7 +1055,7 @@ struct _Container_base12 {
 public:
     _CONSTEXPR20 _Container_base12() noexcept = default;
 
-    _Container_base12(const _Container_base12&) = delete;
+    _Container_base12(const _Container_base12&)            = delete;
     _Container_base12& operator=(const _Container_base12&) = delete;
 
     _CONSTEXPR20 void _Orphan_all() noexcept;
@@ -1290,7 +1290,7 @@ struct _Leave_proxy_unbound {
 }; // tag to indicate that a proxy is being allocated before it is safe to bind to a _Container_base12
 
 struct _Fake_proxy_ptr_impl { // fake replacement for a container proxy smart pointer when no container proxy is in use
-    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&) = delete;
+    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&)            = delete;
     _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
     _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
     _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
@@ -1465,7 +1465,7 @@ struct _NODISCARD _Uninitialized_backout {
 
     constexpr _Uninitialized_backout(_NoThrowFwdIt _First_, _NoThrowFwdIt _Last_) : _First(_First_), _Last(_Last_) {}
 
-    _Uninitialized_backout(const _Uninitialized_backout&) = delete;
+    _Uninitialized_backout(const _Uninitialized_backout&)            = delete;
     _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;
 
     _CONSTEXPR20 ~_Uninitialized_backout() {
@@ -1652,7 +1652,7 @@ private:
 public:
     _CONSTEXPR20 _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
 
-    _Uninitialized_backout_al(const _Uninitialized_backout_al&) = delete;
+    _Uninitialized_backout_al(const _Uninitialized_backout_al&)            = delete;
     _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;
 
     _CONSTEXPR20 ~_Uninitialized_backout_al() {
@@ -1683,30 +1683,23 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
     // note: only called internally from elsewhere in the STL
     using _Ptrval = typename _Alloc::value_type*;
 
-    auto _UFirst      = _Get_unwrapped(_STD move(_First));
-    const auto _ULast = _Get_unwrapped(_STD move(_Last));
+    auto _UFirst = _Get_unwrapped(_STD move(_First));
+    auto _ULast  = _Get_unwrapped(_STD move(_Last));
 
-    constexpr bool _Same_types = is_same_v<const decltype(_UFirst), decltype(_ULast)>;
-    constexpr bool _Can_memmove =
-        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>, //
-        _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>
-        && (_Same_types
-#ifdef __cpp_lib_ranges
-            || sized_sentinel_for<remove_const_t<decltype(_ULast)>, decltype(_UFirst)>
-#endif // __cpp_lib_ranges
-        );
+    constexpr bool _Can_memmove = _Sent_copy_cat<decltype(_UFirst), decltype(_ULast), _Ptrval>::_Bitcopy_assignable //
+                               && _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>::value;
 
     if constexpr (_Can_memmove) {
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            if constexpr (_Same_types) {
-                _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
+            if constexpr (is_same_v<decltype(_UFirst), decltype(_ULast)>) {
+                _Copy_memmove(_To_address(_UFirst), _To_address(_ULast), _Unfancy(_Dest));
                 _Dest += _ULast - _UFirst;
             } else {
                 const auto _Count = static_cast<size_t>(_ULast - _UFirst);
-                _Copy_memmove_n(_UFirst, _Count, _Unfancy(_Dest));
+                _Copy_memmove_n(_To_address(_UFirst), _Count, _Unfancy(_Dest));
                 _Dest += _Count;
             }
             return _Dest;
@@ -2024,7 +2017,7 @@ struct _Alloc_temporary2 {
         _Traits::construct(_Al, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...);
     }
 
-    _Alloc_temporary2(const _Alloc_temporary2&) = delete;
+    _Alloc_temporary2(const _Alloc_temporary2&)            = delete;
     _Alloc_temporary2& operator=(const _Alloc_temporary2&) = delete;
 
     _CONSTEXPR20 ~_Alloc_temporary2() {
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 7eebef24e5..0a29aed06c 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -1220,7 +1220,7 @@ public:
 
     constexpr basic_string_view() noexcept : _Mydata(), _Mysize(0) {}
 
-    constexpr basic_string_view(const basic_string_view&) noexcept = default;
+    constexpr basic_string_view(const basic_string_view&) noexcept            = default;
     constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;
 
     /* implicit */ constexpr basic_string_view(_In_z_ const const_pointer _Ntcts) noexcept // strengthened
@@ -2409,6 +2409,12 @@ _INLINE_VAR constexpr bool _Has_minimum_allocation_alignment_string<_String,
 #pragma detect_mismatch("annotate_string", "0")
 #endif // !_INSERT_STRING_ANNOTATION
 
+#ifdef __cpp_lib_containers_ranges
+template <class _Rng, class _Ty>
+concept _Contiguous_range_of =
+    _RANGES contiguous_range<_Rng> && same_as<remove_cvref_t<_RANGES range_reference_t<_Rng>>, _Ty>;
+#endif // __cpp_lib_containers_ranges
+
 template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_string { // null-terminated transparent array of elements
 private:
@@ -2666,6 +2672,10 @@ public:
             if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
                 _Construct<_Construct_strategy::_From_ptr>(
                     _UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+            } else if constexpr (_Is_fwd_iter_v<decltype(_UFirst)>) {
+                const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+                const auto _Count  = _Convert_size<size_type>(_Length);
+                _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast), _Count);
             } else {
                 _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast));
             }
@@ -2742,8 +2752,11 @@ private:
         _Proxy._Release();
     }
 
-    template <class _Iter>
-    _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Iter _Last) {
+    template <class _Iter, class _Sent, class _Size = nullptr_t>
+    _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
+        // Pre: _First models input_iterator or meets the Cpp17InputIterator requirements
+        // Pre: [_First, Last) is a valid range
+        // Pre: if is_same_v<_Size, size_type>, _Count is the length of [First, Last).
         // Pre: *this is in SSO mode; the lifetime of the SSO elements has already begun
 
         auto& _My_data  = _Mypair._Myval2;
@@ -2754,8 +2767,7 @@ private:
         _My_data._Mysize = 0;
         _My_data._Myres  = _BUF_SIZE - 1;
 
-        if constexpr (_Is_fwd_iter_v<_Iter>) {
-            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(_STD distance(_First, _Last)));
+        if constexpr (is_same_v<_Size, size_type>) {
             if (_Count > max_size()) {
                 _Xlen_string(); // result too long
             }
@@ -2776,7 +2788,7 @@ private:
 
         _Tidy_deallocate_guard<basic_string> _Guard{this};
         for (; _First != _Last; ++_First) {
-            if constexpr (!_Is_fwd_iter_v<_Iter>) {
+            if constexpr (!is_same_v<_Size, size_type>) {
                 if (_My_data._Mysize == _My_data._Myres) { // Need to grow
                     if (_My_data._Mysize == max_size()) {
                         _Xlen_string(); // result too long
@@ -2819,44 +2831,17 @@ public:
     template <_Container_compatible_range<_Elem> _Rng>
     constexpr basic_string(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
         : _Mypair(_One_then_variadic_args_t{}, _Al) {
-        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
-        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
-        _Tidy_init();
-
-        if constexpr (_RANGES sized_range<_Rng>) {
-            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
-
-            if constexpr (contiguous_iterator<decltype(_RANGES _Ubegin(_Range))> && //
-                          same_as<_RANGES range_value_t<_Rng>, _Elem>) {
-                if (_Count != 0) {
-                    const auto _Ptr = _STD to_address(_RANGES _Ubegin(_Range));
-                    assign(_Ptr, _Count);
-                }
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            if constexpr (_Contiguous_range_of<_Rng, _Elem>) {
+                _Construct<_Construct_strategy::_From_ptr>(_RANGES data(_Range), _Count);
             } else {
-                reserve(_Count);
-                _Tidy_deallocate_guard<basic_string> _Guard{this};
-                auto _First      = _RANGES _Ubegin(_Range);
-                const auto _Last = _RANGES _Uend(_Range);
-
-                for (; _First != _Last; ++_First) {
-                    _Push_back_unchecked(*_First);
-                }
-
-                _Guard._Target = nullptr;
+                _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range), _Count);
             }
         } else {
-            _Tidy_deallocate_guard<basic_string> _Guard{this};
-            auto _First      = _RANGES _Ubegin(_Range);
-            const auto _Last = _RANGES _Uend(_Range);
-
-            for (; _First != _Last; ++_First) {
-                push_back(*_First);
-            }
-
-            _Guard._Target = nullptr;
+            _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
         }
-
-        _Proxy._Release();
     }
 #endif // __cpp_lib_containers_ranges
 
@@ -3437,11 +3422,9 @@ public:
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Elem> _Rng>
     constexpr basic_string& append_range(_Rng&& _Range) {
-        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))> //
-                      && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
-            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
-            return append(_Ptr, _Count);
+            return append(_RANGES data(_Range), _Count);
         } else {
             const basic_string _Right(from_range, _Range, get_allocator());
             return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
@@ -3544,13 +3527,9 @@ public:
 #ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Elem> _Rng>
     constexpr basic_string& assign_range(_Rng&& _Range) {
-        // clang-format off
-        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
-            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
-            // clang-format on
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
-            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
-            return assign(_Ptr, _Count);
+            return assign(_RANGES data(_Range), _Count);
         } else {
             basic_string _Right(from_range, _Range, get_allocator());
             if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
@@ -3600,8 +3579,8 @@ public:
         _Mypair._Myval2._Check_offset(_Off);
         const size_type _Old_size = _Mypair._Myval2._Mysize;
 
-        // checking for overlapping ranges is technically UB (considering string literals), so just always
-        // reallocate and copy to the new buffer if constant evaluated
+        // We can't check for overlapping ranges when constant evaluated since comparison of pointers into string
+        // literals is unspecified, so always reallocate and copy to the new buffer if constant evaluated.
 #if _HAS_CXX20
         const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size && !_STD is_constant_evaluated();
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
@@ -3722,13 +3701,9 @@ public:
 #endif // _ITERATOR_DEBUG_LEVEL != 0
         const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
 
-        // clang-format off
-        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
-            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
-            // clang-format on
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
-            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
-            insert(_Off, _Ptr, _Count);
+            insert(_Off, _RANGES data(_Range), _Count);
         } else {
             const basic_string _Right(from_range, _Range, get_allocator());
             insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
@@ -4012,13 +3987,9 @@ public:
         const auto _Off    = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
         const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
 
-        // clang-format off
-        if constexpr (_RANGES sized_range<_Rng> && contiguous_iterator<decltype(_RANGES _Ubegin(_Range))>
-            && same_as<_RANGES range_value_t<_Rng>, _Elem>) {
-            // clang-format on
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
             const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
-            const auto _Ptr   = _STD to_address(_RANGES _Ubegin(_Range));
-            return replace(_Off, _Length, _Ptr, _Count);
+            return replace(_Off, _Length, _RANGES data(_Range), _Count);
         } else {
             const basic_string _Right(from_range, _Range, get_allocator());
             return replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
@@ -4159,20 +4130,6 @@ public:
     }
 #endif // _HAS_CXX17
 
-#ifdef __cpp_lib_containers_ranges
-private:
-    constexpr void _Push_back_unchecked(const _Elem _Ch) { // insert element at end; assume available capacity
-        const size_type _Old_size = _Mypair._Myval2._Mysize;
-        _STL_INTERNAL_CHECK(_Old_size < _Mypair._Myval2._Myres);
-        _Mypair._Myval2._Mysize = _Old_size + 1;
-        _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
-        _Traits::assign(_Ptr[_Old_size], _Ch);
-        _Traits::assign(_Ptr[_Old_size + 1], _Elem());
-    }
-
-public:
-#endif // __cpp_lib_containers_ranges
-
     _CONSTEXPR20 void push_back(const _Elem _Ch) { // insert element at end
         const size_type _Old_size = _Mypair._Myval2._Mysize;
         if (_Old_size < _Mypair._Myval2._Myres) {
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 37759dc2ef..0c31e7fc5e 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -3785,7 +3785,7 @@ namespace ranges {
     _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
         // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
         if constexpr (common_range<_Rng>) {
-            if constexpr (same_as<_Unwrapped_t<_RANGES iterator_t<_Rng>>, decltype(_Uend(_Range))>) {
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_t<iterator_t<_Rng>>>) {
                 return _Uend(_Range);
             } else {
                 return _Get_unwrapped(_RANGES end(_Range));
@@ -3802,7 +3802,11 @@ namespace ranges {
         // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
         // Pre: [ranges::begin(_Range), _Mid) and [_Mid, ranges::end(_Range)) denote ranges
         if constexpr (common_range<_Rng>) {
-            return _Uend(_Range);
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_t<iterator_t<_Rng>>>) {
+                return _Uend(_Range);
+            } else {
+                return _Get_unwrapped(_RANGES end(_Range));
+            }
         } else if constexpr (sized_range<_Rng>) {
             const auto _Dist = _RANGES distance(_Range);
             if constexpr (sized_sentinel_for<_Unwrapped_t<iterator_t<_Rng>>, _Unwrapped_t<iterator_t<_Rng>>>) {
@@ -3847,7 +3851,6 @@ namespace ranges {
                     _Result = _Copy_memmove(_STD move(_First), _Last, _STD move(_Result));
                     return {_STD move(_Last), _STD move(_Result)};
                 } else {
-                    _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Se, _It>);
                     const auto _Count = static_cast<size_t>(_Last - _First);
                     _Result           = _Copy_memmove_n(_First, _Count, _STD move(_Result));
                     _First += _Count;

From 06614a3b583a10022d1abd72c74a5418f9db9184 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Mon, 25 Jul 2022 16:22:26 -0700
Subject: [PATCH 15/37] Revert clang-format noise

---
 stl/inc/ranges  | 10 +++++-----
 stl/inc/vector  |  4 ++--
 stl/inc/xmemory | 14 +++++++-------
 stl/inc/xstring |  2 +-
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 3507bd87f3..6d168bb60d 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -231,7 +231,7 @@ namespace ranges {
         ~_Cached_position() = default;
 
         // Offsets are oblivious to copying, so cache values _do_ propagate via copying.
-        _Cached_position(const _Cached_position&)            = default;
+        _Cached_position(const _Cached_position&) = default;
         _Cached_position& operator=(const _Cached_position&) = default;
 
         // Offsets are potentially invalidated by move, so source caches are invalidated after move
@@ -1358,7 +1358,7 @@ namespace ranges {
             _Iterator(_Iterator&&)      = default;
 
             _Iterator& operator=(const _Iterator&) = delete;
-            _Iterator& operator=(_Iterator&&)      = default;
+            _Iterator& operator=(_Iterator&&) = default;
 
             _Iterator& operator++() {
 #if _ITERATOR_DEBUG_LEVEL != 0
@@ -1503,7 +1503,7 @@ namespace ranges {
         constexpr owning_view(_Rng&& _Range_) noexcept(is_nothrow_move_constructible_v<_Rng>) // strengthened
             : _Range(_STD move(_Range_)) {}
 
-        owning_view(owning_view&&)            = default;
+        owning_view(owning_view&&) = default;
         owning_view& operator=(owning_view&&) = default;
 
         _NODISCARD constexpr _Rng& base() & noexcept {
@@ -5275,7 +5275,7 @@ namespace ranges {
             using difference_type  = range_difference_t<_Vw>;
             using value_type       = range_value_t<_Vw>;
 
-            _Inner_iterator(_Inner_iterator&&)            = default;
+            _Inner_iterator(_Inner_iterator&&) = default;
             _Inner_iterator& operator=(_Inner_iterator&&) = default;
 
             _NODISCARD constexpr const iterator_t<_Vw>& base() const& noexcept /* strengthened */ {
@@ -5384,7 +5384,7 @@ namespace ranges {
                 }
             };
 
-            _Outer_iterator(_Outer_iterator&&)            = default;
+            _Outer_iterator(_Outer_iterator&&) = default;
             _Outer_iterator& operator=(_Outer_iterator&&) = default;
 
             _NODISCARD constexpr value_type operator*() const noexcept /* strengthened */ {
diff --git a/stl/inc/vector b/stl/inc/vector
index ee086a697d..8d9e83842e 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -602,7 +602,7 @@ private:
 
     class _NODISCARD _Asan_extend_guard {
     public:
-        _Asan_extend_guard(const _Asan_extend_guard&)            = delete;
+        _Asan_extend_guard(const _Asan_extend_guard&) = delete;
         _Asan_extend_guard& operator=(const _Asan_extend_guard&) = delete;
 
         constexpr explicit _Asan_extend_guard(vector* _Myvec_, size_type _Target_size_) noexcept
@@ -633,7 +633,7 @@ private:
 
     class _NODISCARD _Asan_create_guard {
     public:
-        _Asan_create_guard(const _Asan_create_guard&)            = delete;
+        _Asan_create_guard(const _Asan_create_guard&) = delete;
         _Asan_create_guard& operator=(const _Asan_create_guard&) = delete;
 
         constexpr explicit _Asan_create_guard(const vector& _Myvec_) noexcept : _Myvec(_Myvec_) {}
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 537f05e8b4..0bf72527a3 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -823,7 +823,7 @@ public:
     constexpr allocator(const allocator&) noexcept = default;
     template <class _Other>
     constexpr allocator(const allocator<_Other>&) noexcept {}
-    _CONSTEXPR20 ~allocator()                           = default;
+    _CONSTEXPR20 ~allocator()       = default;
     _CONSTEXPR20 allocator& operator=(const allocator&) = default;
 
     _CONSTEXPR20 void deallocate(_Ty* const _Ptr, const size_t _Count) {
@@ -1020,7 +1020,7 @@ struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_
         }
     }
 
-    _Alloc_construct_ptr(const _Alloc_construct_ptr&)            = delete;
+    _Alloc_construct_ptr(const _Alloc_construct_ptr&) = delete;
     _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete;
 };
 
@@ -1055,7 +1055,7 @@ struct _Container_base12 {
 public:
     _CONSTEXPR20 _Container_base12() noexcept = default;
 
-    _Container_base12(const _Container_base12&)            = delete;
+    _Container_base12(const _Container_base12&) = delete;
     _Container_base12& operator=(const _Container_base12&) = delete;
 
     _CONSTEXPR20 void _Orphan_all() noexcept;
@@ -1290,7 +1290,7 @@ struct _Leave_proxy_unbound {
 }; // tag to indicate that a proxy is being allocated before it is safe to bind to a _Container_base12
 
 struct _Fake_proxy_ptr_impl { // fake replacement for a container proxy smart pointer when no container proxy is in use
-    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&)            = delete;
+    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&) = delete;
     _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
     _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
     _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
@@ -1465,7 +1465,7 @@ struct _NODISCARD _Uninitialized_backout {
 
     constexpr _Uninitialized_backout(_NoThrowFwdIt _First_, _NoThrowFwdIt _Last_) : _First(_First_), _Last(_Last_) {}
 
-    _Uninitialized_backout(const _Uninitialized_backout&)            = delete;
+    _Uninitialized_backout(const _Uninitialized_backout&) = delete;
     _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;
 
     _CONSTEXPR20 ~_Uninitialized_backout() {
@@ -1652,7 +1652,7 @@ private:
 public:
     _CONSTEXPR20 _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
 
-    _Uninitialized_backout_al(const _Uninitialized_backout_al&)            = delete;
+    _Uninitialized_backout_al(const _Uninitialized_backout_al&) = delete;
     _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;
 
     _CONSTEXPR20 ~_Uninitialized_backout_al() {
@@ -2017,7 +2017,7 @@ struct _Alloc_temporary2 {
         _Traits::construct(_Al, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...);
     }
 
-    _Alloc_temporary2(const _Alloc_temporary2&)            = delete;
+    _Alloc_temporary2(const _Alloc_temporary2&) = delete;
     _Alloc_temporary2& operator=(const _Alloc_temporary2&) = delete;
 
     _CONSTEXPR20 ~_Alloc_temporary2() {
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 0a29aed06c..4de278d8d6 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -1220,7 +1220,7 @@ public:
 
     constexpr basic_string_view() noexcept : _Mydata(), _Mysize(0) {}
 
-    constexpr basic_string_view(const basic_string_view&) noexcept            = default;
+    constexpr basic_string_view(const basic_string_view&) noexcept = default;
     constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;
 
     /* implicit */ constexpr basic_string_view(_In_z_ const const_pointer _Ntcts) noexcept // strengthened

From 56eadd07fbf728399c043991646e8e3db791ad0c Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Mon, 25 Jul 2022 16:49:30 -0700
Subject: [PATCH 16/37] clang-format

---
 tests/std/tests/P1206R7_ranges_to/test.cpp           | 2 +-
 tests/std/tests/P1206R7_vector_insert_range/test.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P1206R7_ranges_to/test.cpp b/tests/std/tests/P1206R7_ranges_to/test.cpp
index 2eae7a7014..132f7fe664 100644
--- a/tests/std/tests/P1206R7_ranges_to/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to/test.cpp
@@ -173,7 +173,7 @@ struct sequence_instantiator {
 
 struct mappish_instantiator {
     static constexpr std::pair<int, std::string_view> some_pairs[]   = {{0, "0"}, {1, "1a"}, {1, "1b"}, {1, "1c"},
-        {2, "2"}, {3, "3"}, {4, "4"}, {5, "5a"}, {5, "5b"}, {6, "6"}, {7, "7"}};
+          {2, "2"}, {3, "3"}, {4, "4"}, {5, "5a"}, {5, "5b"}, {6, "6"}, {7, "7"}};
     static constexpr std::pair<int, std::string_view> unique_pairs[] = {
         {0, "0"}, {1, "1a"}, {2, "2"}, {3, "3"}, {4, "4"}, {5, "5a"}, {6, "6"}, {7, "7"}};
 
diff --git a/tests/std/tests/P1206R7_vector_insert_range/test.cpp b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
index 5f9a0713e8..f2626a767b 100644
--- a/tests/std/tests/P1206R7_vector_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
@@ -63,7 +63,7 @@ static constexpr int other_ints[80]       = { //
 static constexpr int other_short_result[] = {true, false, true, true, true, true, true, true, true, true, true, true,
     true}; // result of inserting other_ints at offset 1 in a sequence of 5 trues
 static constexpr int other_long_result[]  = {true, false, true, true, true, true, true, true, true, true, true, true,
-    true, true, true, true, true, true, true}; // ditto, in a sequence of 11 trues
+     true, true, true, true, true, true, true}; // ditto, in a sequence of 11 trues
 
 struct vector_boo_instantiator {
     template <ranges::input_range R>

From 1612f7b4924f8930bf082b5692e1a0124c19c7bc Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Wed, 27 Jul 2022 17:21:40 -0700
Subject: [PATCH 17/37] Nicole's review comments

---
 .../tests/P1206R7_deque_insert_range/test.cpp |  5 +-
 .../P1206R7_deque_prepend_range/test.cpp      |  1 +
 .../P1206R7_forward_list_from_range/test.cpp  |  1 -
 .../test.cpp                                  |  4 +-
 .../test.cpp                                  |  1 +
 .../tests/P1206R7_list_from_range/test.cpp    |  2 +-
 .../tests/P1206R7_list_prepend_range/test.cpp |  1 +
 .../std/tests/P1206R7_map_from_range/test.cpp |  5 +-
 .../tests/P1206R7_map_insert_range/test.cpp   |  5 +-
 .../P1206R7_multimap_from_range/test.cpp      |  4 +-
 .../P1206R7_multimap_insert_range/test.cpp    |  6 ++-
 .../test.cpp                                  |  5 +-
 .../test.cpp                                  |  4 +-
 .../P1206R7_string_append_range/test.cpp      |  2 +
 .../P1206R7_unordered_map_from_range/test.cpp |  5 +-
 .../test.cpp                                  |  5 +-
 .../test.cpp                                  |  4 +-
 .../test.cpp                                  |  4 +-
 .../P1206R7_unordered_set_from_range/test.cpp |  2 +-
 .../test.cpp                                  |  2 +-
 .../P1206R7_vector_append_range/test.cpp      | 38 +++++++-------
 .../P1206R7_vector_assign_range/test.cpp      | 50 +++++++++----------
 .../tests/P1206R7_vector_from_range/test.cpp  | 34 ++++++-------
 .../P1206R7_vector_insert_range/test.cpp      | 44 ++++++++--------
 24 files changed, 124 insertions(+), 110 deletions(-)

diff --git a/tests/std/tests/P1206R7_deque_insert_range/test.cpp b/tests/std/tests/P1206R7_deque_insert_range/test.cpp
index 8b9bd8eb61..abb64df7a1 100644
--- a/tests/std/tests/P1206R7_deque_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_deque_insert_range/test.cpp
@@ -18,8 +18,9 @@ using namespace std;
 template <ranges::input_range Rng, ranges::random_access_range Expected>
 void test_deque(const size_t presize, Rng&& rng, Expected&& expected) {
     deque<int> d(presize, -1);
-    const same_as<deque<int>::iterator> auto result = d.insert_range(d.begin() + (presize != 0), forward<Rng>(rng));
-    assert(result == d.begin() + (presize != 0));
+    const same_as<deque<int>::iterator> auto result =
+        d.insert_range(ranges::next(d.begin(), presize != 0), forward<Rng>(rng));
+    assert(result == ranges::next(d.begin(), presize != 0));
     assert(ranges::equal(d, expected));
 }
 
diff --git a/tests/std/tests/P1206R7_deque_prepend_range/test.cpp b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
index ac3f75df5a..b91fcd46d1 100644
--- a/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 #include <deque>
 #include <forward_list>
 #include <ranges>
diff --git a/tests/std/tests/P1206R7_forward_list_from_range/test.cpp b/tests/std/tests/P1206R7_forward_list_from_range/test.cpp
index 4dded78cba..1d4687f400 100644
--- a/tests/std/tests/P1206R7_forward_list_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_forward_list_from_range/test.cpp
@@ -17,7 +17,6 @@ using namespace std;
 template <ranges::input_range Rng, ranges::random_access_range Expected>
 void test_flist(Rng&& rng, Expected&& expected) {
     forward_list<int> fl{from_range, forward<Rng>(rng)};
-    static_assert(same_as<decltype(fl), forward_list<int>>);
     assert(ranges::equal(fl, expected));
 }
 
diff --git a/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp b/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
index c9c7d795a5..6a2b04e837 100644
--- a/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
@@ -18,8 +18,8 @@ template <ranges::input_range Rng, ranges::random_access_range Expected>
 void test_flist(const size_t presize, Rng&& rng, Expected&& expected) {
     forward_list<int> fl(presize, -1);
     const same_as<forward_list<int>::iterator> auto result =
-        fl.insert_range_after(presize ? fl.begin() : fl.before_begin(), forward<Rng>(rng));
-    assert(result == ranges::next(presize ? fl.begin() : fl.before_begin(), 8));
+        fl.insert_range_after(ranges::next(fl.before_begin(), presize != 0), forward<Rng>(rng));
+    assert(result == ranges::next(fl.before_begin(), 8 + (presize != 0)));
     assert(ranges::equal(fl, expected));
 }
 
diff --git a/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
index 2085bc8998..b9933a4ee1 100644
--- a/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 #include <forward_list>
 #include <ranges>
 #include <span>
diff --git a/tests/std/tests/P1206R7_list_from_range/test.cpp b/tests/std/tests/P1206R7_list_from_range/test.cpp
index 0e1de022ec..37265b68cc 100644
--- a/tests/std/tests/P1206R7_list_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_list_from_range/test.cpp
@@ -17,7 +17,7 @@ using namespace std;
 
 template <ranges::input_range Rng, ranges::random_access_range Expected>
 void test_list(Rng&& rng, Expected&& expected) {
-    list<int> lst(from_range, forward<Rng>(rng));
+    list<int> lst{from_range, forward<Rng>(rng)};
     assert(ranges::equal(lst, expected));
 }
 
diff --git a/tests/std/tests/P1206R7_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
index e1261974d2..13ad0df9bb 100644
--- a/tests/std/tests/P1206R7_list_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 #include <forward_list>
 #include <list>
 #include <ranges>
diff --git a/tests/std/tests/P1206R7_map_from_range/test.cpp b/tests/std/tests/P1206R7_map_from_range/test.cpp
index 5d06652428..3bcd258989 100644
--- a/tests/std/tests/P1206R7_map_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_map_from_range/test.cpp
@@ -15,7 +15,7 @@
 
 using namespace std;
 
-static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_map(Rng&& rng) {
@@ -25,7 +25,8 @@ void test_map(Rng&& rng) {
     }
 }
 
-static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct map_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_map_insert_range/test.cpp b/tests/std/tests/P1206R7_map_insert_range/test.cpp
index 947a2ab180..c230c2c5d5 100644
--- a/tests/std/tests/P1206R7_map_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_map_insert_range/test.cpp
@@ -15,7 +15,7 @@
 
 using namespace std;
 
-static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_map(Rng&& rng) {
@@ -26,7 +26,8 @@ void test_map(Rng&& rng) {
     }
 }
 
-static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct map_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_multimap_from_range/test.cpp b/tests/std/tests/P1206R7_multimap_from_range/test.cpp
index 8172c81203..9728de290b 100644
--- a/tests/std/tests/P1206R7_multimap_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_multimap_from_range/test.cpp
@@ -16,7 +16,7 @@
 using namespace std;
 
 static constexpr pair<int, int> expected[] = {
-    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 16}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_multimap(Rng&& rng) {
@@ -27,7 +27,7 @@ void test_multimap(Rng&& rng) {
 }
 
 static constexpr pair<int, int> some_pairs[] = {
-    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 16}, {5, 15}, {6, 14}, {4, 16}, {7, 13}, {1, 19}};
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct multimap_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_multimap_insert_range/test.cpp b/tests/std/tests/P1206R7_multimap_insert_range/test.cpp
index 68b19fea60..3582dce6f4 100644
--- a/tests/std/tests/P1206R7_multimap_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_multimap_insert_range/test.cpp
@@ -15,7 +15,8 @@
 
 using namespace std;
 
-static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+static constexpr pair<int, int> expected[] = {
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_multimap(Rng&& rng) {
@@ -26,7 +27,8 @@ void test_multimap(Rng&& rng) {
     }
 }
 
-static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct multimap_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
index 44aff1e9cb..3b882c4fa4 100644
--- a/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
@@ -4,7 +4,6 @@
 #include <algorithm>
 #include <cassert>
 #include <forward_list>
-#include <new>
 #include <queue>
 #include <ranges>
 #include <span>
@@ -28,14 +27,14 @@ struct adaptor_adaptor : T {
     }
 };
 
-static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
-
 template <ranges::input_range R, class... Args>
 void test_priority_queue(R&& r, Args&&... args) {
     adaptor_adaptor<priority_queue<int>> s{from_range, r, forward<Args>(args)...};
     assert(ranges::is_heap(s.get_container()));
 }
 
+static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
+
 struct instantiator {
     template <ranges::input_range R>
     static void call() {
diff --git a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
index 2ef6c7800f..fd01b9d8c5 100644
--- a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
@@ -29,8 +29,6 @@ struct adaptor_adaptor : T {
     }
 };
 
-static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
-
 template <ranges::input_range Rng>
 void test_priority_queue(const size_t presize, Rng&& rng) {
     adaptor_adaptor<priority_queue<int>> pq{less<int>{}, vector<int>(presize, -1)};
@@ -40,6 +38,8 @@ void test_priority_queue(const size_t presize, Rng&& rng) {
     assert(ranges::is_heap(container));
 }
 
+static constexpr int some_ints[] = {0, 7, 1, 6, 2, 5, 3, 4};
+
 template <ranges::input_range Rng>
 void test_priority_queue() {
     test_priority_queue(0, Rng{some_ints});
diff --git a/tests/std/tests/P1206R7_string_append_range/test.cpp b/tests/std/tests/P1206R7_string_append_range/test.cpp
index 146e617594..edd929833a 100644
--- a/tests/std/tests/P1206R7_string_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_string_append_range/test.cpp
@@ -18,6 +18,8 @@ using namespace std;
 
 template <ranges::input_range Rng, class T, size_t N>
 constexpr bool test_string(const size_t capacity, const size_t presize, Rng&& rng, const T (&expected)[N]) {
+    // We need to test both reallocating and non-reallocating code paths,
+    // so we accept distinct capacity and size values for the initial container.
     basic_string<T> str;
     str.reserve(capacity);
     str.resize(presize, T{'x'});
diff --git a/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
index cc8dabb4ba..034c7117d9 100644
--- a/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_map_from_range/test.cpp
@@ -15,7 +15,7 @@
 
 using namespace std;
 
-static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_unordered_map(Rng&& rng) {
@@ -26,7 +26,8 @@ void test_unordered_map(Rng&& rng) {
     }
 }
 
-static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct unordered_map_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
index ddd7785e4f..e034d4dba0 100644
--- a/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_map_insert_range/test.cpp
@@ -15,7 +15,7 @@
 
 using namespace std;
 
-static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 15}, {6, 14}, {7, 13}};
+static constexpr pair<int, int> expected[] = {{0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_unordered_map(Rng&& rng) {
@@ -27,7 +27,8 @@ void test_unordered_map(Rng&& rng) {
     }
 }
 
-static constexpr pair<int, int> some_pairs[] = {{4, 16}, {2, 18}, {3, 17}, {0, 20}, {5, 15}, {6, 14}, {7, 13}, {1, 19}};
+static constexpr pair<int, int> some_pairs[] = {
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct unordered_map_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
index c3033a72ae..b04ebe861d 100644
--- a/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_multimap_from_range/test.cpp
@@ -16,7 +16,7 @@
 using namespace std;
 
 static constexpr pair<int, int> expected[] = {
-    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 100}, {4, 101}, {5, 15}, {6, 14}, {7, 13}};
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_unordered_multimap(Rng&& rng) {
@@ -28,7 +28,7 @@ void test_unordered_multimap(Rng&& rng) {
 }
 
 static constexpr pair<int, int> some_pairs[] = {
-    {4, 16}, {2, 18}, {3, 17}, {4, 100}, {0, 20}, {5, 15}, {4, 101}, {6, 14}, {7, 13}, {1, 19}};
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct unordered_multimap_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
index 94adfcb761..097f759143 100644
--- a/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
@@ -16,7 +16,7 @@
 using namespace std;
 
 static constexpr pair<int, int> expected[] = {
-    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 100}, {4, 101}, {5, 15}, {6, 14}, {7, 13}};
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_unordered_multimap(Rng&& rng) {
@@ -29,7 +29,7 @@ void test_unordered_multimap(Rng&& rng) {
 }
 
 static constexpr pair<int, int> some_pairs[] = {
-    {4, 16}, {2, 18}, {3, 17}, {4, 100}, {0, 20}, {5, 15}, {4, 101}, {6, 14}, {7, 13}, {1, 19}};
+    {4, 16}, {2, 18}, {3, 17}, {0, 20}, {4, 15}, {5, 13}, {6, 12}, {4, 14}, {5, 13}, {7, 11}, {1, 19}};
 
 struct unordered_multimap_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp b/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
index 60d99ffb26..8398465e91 100644
--- a/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_set_from_range/test.cpp
@@ -26,7 +26,7 @@ void test_unordered_set(Rng&& rng) {
     }
 }
 
-static constexpr int some_ints[] = {4, 2, 3, 0, 5, 6, 7, 1};
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
 
 struct unordered_set_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
index c9d2a532b4..9ea4da73c3 100644
--- a/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_set_insert_range/test.cpp
@@ -27,7 +27,7 @@ void test_unordered_set(Rng&& rng) {
     }
 }
 
-static constexpr int some_ints[] = {4, 2, 3, 0, 5, 6, 7, 1};
+static constexpr int some_ints[] = {4, 2, 3, 4, 0, 5, 4, 6, 7, 1};
 
 struct unordered_set_instantiator {
     template <ranges::input_range R>
diff --git a/tests/std/tests/P1206R7_vector_append_range/test.cpp b/tests/std/tests/P1206R7_vector_append_range/test.cpp
index df37546f59..39237770ab 100644
--- a/tests/std/tests/P1206R7_vector_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_append_range/test.cpp
@@ -17,6 +17,8 @@ using namespace std;
 
 template <ranges::input_range Rng, size_t N>
 constexpr bool test_vector(const size_t capacity, const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    // We need to test both reallocating and non-reallocating code paths,
+    // so we accept distinct capacity and size values for the initial container.
     vector<int> vec;
     vec.reserve(capacity);
     vec.resize(presize, -1);
@@ -48,7 +50,9 @@ struct vector_instantiator {
 };
 
 template <ranges::input_range Rng, size_t N>
-constexpr bool test_vector_boo(const size_t capacity, const size_t presize, Rng&& rng, const int (&expected)[N]) {
+constexpr bool test_vector_bool(const size_t capacity, const size_t presize, Rng&& rng, const int (&expected)[N]) {
+    // We need to test both reallocating and non-reallocating code paths,
+    // so we accept distinct capacity and size values for the initial container.
     vector<bool> vec;
     vec.reserve(capacity);
     vec.resize(presize, true);
@@ -62,9 +66,9 @@ constexpr bool test_vector_boo(const size_t capacity, const size_t presize, Rng&
 }
 
 template <ranges::input_range Rng, size_t N>
-constexpr bool test_vector_boo(const int (&expected)[N]) {
-    test_vector_boo(0, 0, Rng{expected}, expected);
-    test_vector_boo(ranges::size(expected) + 2, 2, Rng{expected}, expected);
+constexpr bool test_vector_bool(const int (&expected)[N]) {
+    test_vector_bool(0, 0, Rng{expected}, expected);
+    test_vector_bool(ranges::size(expected) + 2, 2, Rng{expected}, expected);
 
     return true;
 }
@@ -79,8 +83,8 @@ static constexpr int other_ints[80] = { //
 struct vector_boo_instantiator {
     template <ranges::input_range R>
     static constexpr void call() {
-        test_vector_boo<R>(other_ints);
-        STATIC_ASSERT(test_vector_boo<R>(other_ints));
+        test_vector_bool<R>(other_ints);
+        STATIC_ASSERT(test_vector_bool<R>(other_ints));
     }
 };
 
@@ -91,7 +95,7 @@ using move_only_view = test::range<Category, const int, test::Sized{is_random},
 
 constexpr bool test_copyable_view() {
     test_vector<span<const int>>(some_ints);
-    test_vector_boo<span<const int>>(other_ints);
+    test_vector_bool<span<const int>>(other_ints);
     return true;
 }
 
@@ -104,20 +108,20 @@ constexpr bool test_move_only_view() {
     test_vector<move_only_view<random_access_iterator_tag, test::Common::no>>(some_ints);
     test_vector<move_only_view<random_access_iterator_tag, test::Common::yes>>(some_ints);
 
-    test_vector_boo<move_only_view<input_iterator_tag, test::Common::no>>(other_ints);
-    test_vector_boo<move_only_view<forward_iterator_tag, test::Common::no>>(other_ints);
-    test_vector_boo<move_only_view<forward_iterator_tag, test::Common::yes>>(other_ints);
-    test_vector_boo<move_only_view<bidirectional_iterator_tag, test::Common::no>>(other_ints);
-    test_vector_boo<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(other_ints);
-    test_vector_boo<move_only_view<random_access_iterator_tag, test::Common::no>>(other_ints);
-    test_vector_boo<move_only_view<random_access_iterator_tag, test::Common::yes>>(other_ints);
+    test_vector_bool<move_only_view<input_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_bool<move_only_view<forward_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_bool<move_only_view<forward_iterator_tag, test::Common::yes>>(other_ints);
+    test_vector_bool<move_only_view<bidirectional_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_bool<move_only_view<bidirectional_iterator_tag, test::Common::yes>>(other_ints);
+    test_vector_bool<move_only_view<random_access_iterator_tag, test::Common::no>>(other_ints);
+    test_vector_bool<move_only_view<random_access_iterator_tag, test::Common::yes>>(other_ints);
 
     return true;
 }
 
 constexpr bool test_c_array() {
     test_vector(0, 0, some_ints, some_ints);
-    test_vector_boo(0, 0, other_ints, other_ints);
+    test_vector_bool(0, 0, other_ints, other_ints);
     return true;
 }
 
@@ -128,7 +132,7 @@ constexpr bool test_lvalue_vector() {
     }
     {
         vector vec(from_range, other_ints);
-        test_vector_boo(0, 0, vec, other_ints);
+        test_vector_bool(0, 0, vec, other_ints);
     }
     return true;
 }
@@ -140,7 +144,7 @@ void test_lvalue_forward_list() {
     }
     {
         forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(0, 0, lst, other_ints);
+        test_vector_bool(0, 0, lst, other_ints);
     }
 }
 
diff --git a/tests/std/tests/P1206R7_vector_assign_range/test.cpp b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
index e024dcac7d..af2b35ed68 100644
--- a/tests/std/tests/P1206R7_vector_assign_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
@@ -40,7 +40,7 @@ struct vector_instantiator {
 };
 
 template <ranges::input_range Rng, ranges::random_access_range Expected>
-constexpr bool test_vector_boo(const size_t presize, Rng&& rng, Expected&& expected) {
+constexpr bool test_vector_bool(const size_t presize, Rng&& rng, Expected&& expected) {
     vector<bool> vec(presize, true);
     vec.assign_range(forward<Rng>(rng));
     assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
@@ -59,19 +59,19 @@ static constexpr auto first64_ints  = span{other_ints}.first<64>();
 struct vector_boo_instantiator {
     template <ranges::input_range R>
     static void call() {
-        test_vector_boo(0, R{other_ints}, other_ints);
-        STATIC_ASSERT(test_vector_boo(0, R{other_ints}, other_ints));
-        test_vector_boo(40, R{other_ints}, other_ints);
-        STATIC_ASSERT(test_vector_boo(40, R{other_ints}, other_ints));
-        test_vector_boo(ranges::size(other_ints), R{other_ints}, other_ints);
-        STATIC_ASSERT(test_vector_boo(ranges::size(other_ints), R{other_ints}, other_ints));
-
-        test_vector_boo(0, R{first64_ints}, first64_ints);
-        STATIC_ASSERT(test_vector_boo(0, R{first64_ints}, first64_ints));
-        test_vector_boo(40, R{first64_ints}, first64_ints);
-        STATIC_ASSERT(test_vector_boo(40, R{first64_ints}, first64_ints));
-        test_vector_boo(64, R{first64_ints}, first64_ints);
-        STATIC_ASSERT(test_vector_boo(64, R{first64_ints}, first64_ints));
+        test_vector_bool(0, R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_bool(0, R{other_ints}, other_ints));
+        test_vector_bool(40, R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_bool(40, R{other_ints}, other_ints));
+        test_vector_bool(ranges::size(other_ints), R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_bool(ranges::size(other_ints), R{other_ints}, other_ints));
+
+        test_vector_bool(0, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_bool(0, R{first64_ints}, first64_ints));
+        test_vector_bool(40, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_bool(40, R{first64_ints}, first64_ints));
+        test_vector_bool(64, R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_bool(64, R{first64_ints}, first64_ints));
     }
 };
 
@@ -88,7 +88,7 @@ constexpr bool test_copyable_views() {
 
     {
         constexpr span<const int> s{other_ints};
-        test_vector_boo(0, s, other_ints);
+        test_vector_bool(0, s, other_ints);
     }
 
     return true;
@@ -106,13 +106,13 @@ constexpr bool test_move_only_views() {
     }
 
     {
-        test_vector_boo(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
     }
 
     return true;
@@ -120,7 +120,7 @@ constexpr bool test_move_only_views() {
 
 constexpr bool test_c_array() {
     test_vector(0, some_ints, some_ints);
-    test_vector_boo(0, other_ints, other_ints);
+    test_vector_bool(0, other_ints, other_ints);
 
     return true;
 }
@@ -132,7 +132,7 @@ constexpr bool test_lvalue_vector() {
     }
     {
         vector vec(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(0, vec, other_ints);
+        test_vector_bool(0, vec, other_ints);
     }
 
     return true;
@@ -145,7 +145,7 @@ void test_lvalue_forward_list() {
     }
     {
         forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(0, lst, other_ints);
+        test_vector_bool(0, lst, other_ints);
     }
 }
 
diff --git a/tests/std/tests/P1206R7_vector_from_range/test.cpp b/tests/std/tests/P1206R7_vector_from_range/test.cpp
index e1345880ef..465623e734 100644
--- a/tests/std/tests/P1206R7_vector_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_from_range/test.cpp
@@ -33,7 +33,7 @@ struct vector_instantiator {
 };
 
 template <ranges::input_range Rng, ranges::random_access_range Expected>
-constexpr bool test_vector_boo(Rng&& rng, Expected&& expected) {
+constexpr bool test_vector_bool(Rng&& rng, Expected&& expected) {
     vector<bool> vec(from_range, forward<Rng>(rng));
     assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
 
@@ -51,10 +51,10 @@ static constexpr auto first64_ints  = span{other_ints}.first<64>();
 struct vector_boo_instantiator {
     template <ranges::input_range R>
     static void call() {
-        test_vector_boo(R{other_ints}, other_ints);
-        STATIC_ASSERT(test_vector_boo(R{other_ints}, other_ints));
-        test_vector_boo(R{first64_ints}, first64_ints);
-        STATIC_ASSERT(test_vector_boo(R{first64_ints}, first64_ints));
+        test_vector_bool(R{other_ints}, other_ints);
+        STATIC_ASSERT(test_vector_bool(R{other_ints}, other_ints));
+        test_vector_bool(R{first64_ints}, first64_ints);
+        STATIC_ASSERT(test_vector_bool(R{first64_ints}, first64_ints));
     }
 };
 
@@ -70,8 +70,8 @@ constexpr bool test_copyable_views() {
     }
     {
         constexpr span<const int> s{other_ints};
-        test_vector_boo(s, other_ints);
-        test_vector_boo(first64_ints, first64_ints);
+        test_vector_bool(s, other_ints);
+        test_vector_bool(first64_ints, first64_ints);
     }
     return true;
 }
@@ -85,19 +85,19 @@ constexpr bool test_move_only_views() {
     test_vector(move_only_view<random_access_iterator_tag, test::Common::no>{some_ints}, some_ints);
     test_vector(move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
 
-    test_vector_boo(move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
-    test_vector_boo(move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+    test_vector_bool(move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
     return true;
 }
 
 constexpr bool test_c_array() {
     test_vector(some_ints, some_ints);
-    test_vector_boo(other_ints, other_ints);
+    test_vector_bool(other_ints, other_ints);
     return true;
 }
 
@@ -108,7 +108,7 @@ constexpr bool test_lvalue_vector() {
     }
     {
         vector vec(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(vec, other_ints);
+        test_vector_bool(vec, other_ints);
     }
     return true;
 }
@@ -120,7 +120,7 @@ void test_lvalue_forward_list() {
     }
     {
         forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(lst, other_ints);
+        test_vector_bool(lst, other_ints);
     }
 }
 
diff --git a/tests/std/tests/P1206R7_vector_insert_range/test.cpp b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
index f2626a767b..6b9b7a9100 100644
--- a/tests/std/tests/P1206R7_vector_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
@@ -18,8 +18,8 @@ template <ranges::input_range Rng, ranges::random_access_range Expected>
 constexpr bool test_vector(const size_t presize, Rng&& rng, Expected&& expected) {
     vector<int> vec(presize, -1);
     const same_as<vector<int>::iterator> auto result =
-        vec.insert_range(vec.begin() + (presize != 0), forward<Rng>(rng));
-    assert(result == vec.begin() + (presize != 0));
+        vec.insert_range(ranges::next(vec.begin(), presize != 0), forward<Rng>(rng));
+    assert(result == ranges::next(vec.begin(), presize != 0));
     assert(ranges::equal(vec, expected));
 
     return true;
@@ -44,11 +44,11 @@ struct vector_instantiator {
 };
 
 template <ranges::input_range Rng, ranges::random_access_range Expected>
-constexpr bool test_vector_boo(const size_t presize, Rng&& rng, Expected&& expected) {
+constexpr bool test_vector_bool(const size_t presize, Rng&& rng, Expected&& expected) {
     vector<bool> vec(presize, true);
     const same_as<vector<bool>::iterator> auto result =
-        vec.insert_range(vec.begin() + (presize != 0), forward<Rng>(rng));
-    assert(result == vec.begin() + (presize != 0));
+        vec.insert_range(ranges::next(vec.begin(), presize != 0), forward<Rng>(rng));
+    assert(result == ranges::next(vec.begin(), presize != 0));
     assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
 
     return true;
@@ -68,12 +68,12 @@ static constexpr int other_long_result[]  = {true, false, true, true, true, true
 struct vector_boo_instantiator {
     template <ranges::input_range R>
     static void call() {
-        test_vector_boo(0, R{some_ints}, some_ints);
-        STATIC_ASSERT(test_vector_boo(0, R{some_ints}, some_ints));
-        test_vector_boo(5, R{some_ints}, other_short_result);
-        STATIC_ASSERT(test_vector_boo(5, R{some_ints}, other_short_result));
-        test_vector_boo(11, R{some_ints}, other_long_result);
-        STATIC_ASSERT(test_vector_boo(11, R{some_ints}, other_long_result));
+        test_vector_bool(0, R{some_ints}, some_ints);
+        STATIC_ASSERT(test_vector_bool(0, R{some_ints}, some_ints));
+        test_vector_bool(5, R{some_ints}, other_short_result);
+        STATIC_ASSERT(test_vector_bool(5, R{some_ints}, other_short_result));
+        test_vector_bool(11, R{some_ints}, other_long_result);
+        STATIC_ASSERT(test_vector_bool(11, R{some_ints}, other_long_result));
     }
 };
 
@@ -89,7 +89,7 @@ constexpr bool test_copyable_views() {
     }
     {
         constexpr span<const int> s{other_ints};
-        test_vector_boo(0, s, other_ints);
+        test_vector_bool(0, s, other_ints);
     }
 
     return true;
@@ -106,13 +106,13 @@ constexpr bool test_move_only_views() {
         test_vector(0, move_only_view<random_access_iterator_tag, test::Common::yes>{some_ints}, some_ints);
     }
     {
-        test_vector_boo(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
-        test_vector_boo(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<input_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<forward_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<forward_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<bidirectional_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<bidirectional_iterator_tag, test::Common::yes>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<random_access_iterator_tag, test::Common::no>{other_ints}, other_ints);
+        test_vector_bool(0, move_only_view<random_access_iterator_tag, test::Common::yes>{other_ints}, other_ints);
     }
 
     return true;
@@ -120,7 +120,7 @@ constexpr bool test_move_only_views() {
 
 constexpr bool test_c_array() {
     test_vector(0, some_ints, some_ints);
-    test_vector_boo(0, other_ints, other_ints);
+    test_vector_bool(0, other_ints, other_ints);
     return true;
 }
 
@@ -131,7 +131,7 @@ constexpr bool test_lvalue_vector() {
     }
     {
         vector vec(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(0, vec, other_ints);
+        test_vector_bool(0, vec, other_ints);
     }
     return true;
 }
@@ -143,7 +143,7 @@ void test_lvalue_forward_list() {
     }
     {
         forward_list lst(ranges::begin(other_ints), ranges::end(other_ints));
-        test_vector_boo(0, lst, other_ints);
+        test_vector_bool(0, lst, other_ints);
     }
 }
 

From 412e87df670fa30be883c6f4b81b8221ed2d896b Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Wed, 27 Jul 2022 17:31:45 -0700
Subject: [PATCH 18/37] Rename adaptor_adaptor to accessible_adaptor

---
 tests/std/tests/P1206R7_priority_queue_from_range/test.cpp | 4 ++--
 tests/std/tests/P1206R7_priority_queue_push_range/test.cpp | 4 ++--
 tests/std/tests/P1206R7_queue_from_range/test.cpp          | 4 ++--
 tests/std/tests/P1206R7_queue_push_range/test.cpp          | 4 ++--
 tests/std/tests/P1206R7_stack_from_range/test.cpp          | 4 ++--
 tests/std/tests/P1206R7_stack_push_range/test.cpp          | 4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
index 3b882c4fa4..799c66429a 100644
--- a/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_priority_queue_from_range/test.cpp
@@ -16,7 +16,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -29,7 +29,7 @@ struct adaptor_adaptor : T {
 
 template <ranges::input_range R, class... Args>
 void test_priority_queue(R&& r, Args&&... args) {
-    adaptor_adaptor<priority_queue<int>> s{from_range, r, forward<Args>(args)...};
+    accessible_adaptor<priority_queue<int>> s{from_range, r, forward<Args>(args)...};
     assert(ranges::is_heap(s.get_container()));
 }
 
diff --git a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
index fd01b9d8c5..e5166ce0c1 100644
--- a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
@@ -18,7 +18,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -31,7 +31,7 @@ struct adaptor_adaptor : T {
 
 template <ranges::input_range Rng>
 void test_priority_queue(const size_t presize, Rng&& rng) {
-    adaptor_adaptor<priority_queue<int>> pq{less<int>{}, vector<int>(presize, -1)};
+    accessible_adaptor<priority_queue<int>> pq{less<int>{}, vector<int>(presize, -1)};
 
     pq.push_range(forward<Rng>(rng));
     const auto& container = pq.get_container();
diff --git a/tests/std/tests/P1206R7_queue_from_range/test.cpp b/tests/std/tests/P1206R7_queue_from_range/test.cpp
index ea55cf7faf..7a4ae4fbfe 100644
--- a/tests/std/tests/P1206R7_queue_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_queue_from_range/test.cpp
@@ -17,7 +17,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -32,7 +32,7 @@ static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
 
 template <ranges::input_range R, class... Args>
 void test_queue(R&& r, Args&&... args) {
-    adaptor_adaptor<queue<int>> s{from_range, r, forward<Args>(args)...};
+    accessible_adaptor<queue<int>> s{from_range, r, forward<Args>(args)...};
     assert(ranges::equal(s.get_container(), some_ints));
 }
 
diff --git a/tests/std/tests/P1206R7_queue_push_range/test.cpp b/tests/std/tests/P1206R7_queue_push_range/test.cpp
index 5acd02a1b5..781b43d569 100644
--- a/tests/std/tests/P1206R7_queue_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_queue_push_range/test.cpp
@@ -18,7 +18,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -31,7 +31,7 @@ struct adaptor_adaptor : T {
 
 template <ranges::input_range Rng, size_t N>
 void test_queue(const size_t presize, Rng&& rng, const int (&expected)[N]) {
-    adaptor_adaptor<queue<int>> d{deque<int>(presize, -1)};
+    accessible_adaptor<queue<int>> d{deque<int>(presize, -1)};
 
     d.push_range(forward<Rng>(rng));
     const auto count      = static_cast<ptrdiff_t>(presize);
diff --git a/tests/std/tests/P1206R7_stack_from_range/test.cpp b/tests/std/tests/P1206R7_stack_from_range/test.cpp
index c6029f5ed5..8be70dc79f 100644
--- a/tests/std/tests/P1206R7_stack_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_stack_from_range/test.cpp
@@ -17,7 +17,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -32,7 +32,7 @@ static constexpr int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
 
 template <ranges::input_range R, class... Args>
 void test_stack(R&& r, Args&&... args) {
-    adaptor_adaptor<stack<int>> s{from_range, r, forward<Args>(args)...};
+    accessible_adaptor<stack<int>> s{from_range, r, forward<Args>(args)...};
     assert(ranges::equal(s.get_container(), some_ints));
 }
 
diff --git a/tests/std/tests/P1206R7_stack_push_range/test.cpp b/tests/std/tests/P1206R7_stack_push_range/test.cpp
index deb7a6035f..d129b1747a 100644
--- a/tests/std/tests/P1206R7_stack_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_stack_push_range/test.cpp
@@ -18,7 +18,7 @@
 using namespace std;
 
 template <class T>
-struct adaptor_adaptor : T {
+struct accessible_adaptor : T {
     using T::T;
 
     auto& get_container() {
@@ -31,7 +31,7 @@ struct adaptor_adaptor : T {
 
 template <ranges::input_range Rng, size_t N>
 void test_stack(const size_t presize, Rng&& rng, const int (&expected)[N]) {
-    adaptor_adaptor<stack<int>> d{deque<int>(presize, -1)};
+    accessible_adaptor<stack<int>> d{deque<int>(presize, -1)};
 
     d.push_range(forward<Rng>(rng));
     const auto count      = static_cast<ptrdiff_t>(presize);

From baa2afa2207dcbdc9730007e3c80125043efac01 Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Wed, 27 Jul 2022 18:23:40 -0700
Subject: [PATCH 19/37] Surely I don't need to run _all_ the tests before
 pushing??!?

---
 .../std/tests/P1206R7_unordered_multimap_insert_range/test.cpp  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
index 097f759143..d229b6e3d1 100644
--- a/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_unordered_multimap_insert_range/test.cpp
@@ -16,7 +16,7 @@
 using namespace std;
 
 static constexpr pair<int, int> expected[] = {
-    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {6, 12}, {7, 11}};
+    {0, 20}, {1, 19}, {2, 18}, {3, 17}, {4, 16}, {4, 15}, {4, 14}, {5, 13}, {5, 13}, {6, 12}, {7, 11}};
 
 template <ranges::input_range Rng>
 void test_unordered_multimap(Rng&& rng) {

From 148de4b717a7f13254dc6ae52815269bdceab961 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 7 Aug 2022 18:31:05 -0700
Subject: [PATCH 20/37] Fix comment typo.

---
 stl/inc/xstring | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/xstring b/stl/inc/xstring
index 015eafe7f7..bf54308d3b 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2758,7 +2758,7 @@ private:
     _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
         // Pre: _First models input_iterator or meets the Cpp17InputIterator requirements
         // Pre: [_First, Last) is a valid range
-        // Pre: if is_same_v<_Size, size_type>, _Count is the length of [First, Last).
+        // Pre: if is_same_v<_Size, size_type>, _Count is the length of [_First, _Last).
         // Pre: *this is in SSO mode; the lifetime of the SSO elements has already begun
 
         auto& _My_data  = _Mypair._Myval2;

From 748e8fda89527523770999791d56e1001af80bd5 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 7 Aug 2022 18:42:40 -0700
Subject: [PATCH 21/37] Fix merge: apply `_Is_meow_iter_v` =>
 `_Is_cpp17_meow_iter_v` renaming.

---
 stl/inc/deque   | 2 +-
 stl/inc/vector  | 8 ++++----
 stl/inc/xstring | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index a8cead482e..7e28e64ce3 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1377,7 +1377,7 @@ public:
         // insert [_First, _Last) at _Where
         _Adl_verify_range(_First, _Last);
         const size_type _Off = static_cast<size_type>(_Where - begin());
-        return _Insert_range<static_cast<_Is_bidi>(_Is_bidi_iter_v<_Iter>)>(
+        return _Insert_range<static_cast<_Is_bidi>(_Is_cpp17_bidi_iter_v<_Iter>)>(
             _Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
     }
 
diff --git a/stl/inc/vector b/stl/inc/vector
index 9365302e88..1c45c34220 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -694,7 +694,7 @@ public:
         _Adl_verify_range(_First, _Last);
         auto _UFirst = _Get_unwrapped(_First);
         auto _ULast  = _Get_unwrapped(_Last);
-        if constexpr (_Is_fwd_iter_v<_Iter>) {
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
             const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
             const auto _Count  = _Convert_size<size_type>(_Length);
             _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
@@ -1299,7 +1299,7 @@ public:
         auto _UFirst         = _Get_unwrapped(_First);
         auto _ULast          = _Get_unwrapped(_Last);
         const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
-        if constexpr (_Is_fwd_iter_v<_Iter>) {
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
             const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
             const auto _Count  = _Convert_size<size_type>(_Length);
             _Insert_counted_range(_Where, _UFirst, _Count);
@@ -1497,7 +1497,7 @@ public:
         _Adl_verify_range(_First, _Last);
         auto _UFirst = _Get_unwrapped(_First);
         auto _ULast  = _Get_unwrapped(_Last);
-        if constexpr (_Is_fwd_iter_v<_Iter>) {
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
             const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
             const auto _Count  = _Convert_size<size_type>(_Length);
             _Assign_counted_range(_UFirst, _Count);
@@ -3392,7 +3392,7 @@ public:
         auto _UFirst      = _Get_unwrapped(_First);
         const auto _ULast = _Get_unwrapped(_Last);
 
-        if constexpr (_Is_fwd_iter_v<_Iter>) {
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
             const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
             const auto _Count  = _Convert_size<size_type>(_Length);
             const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
diff --git a/stl/inc/xstring b/stl/inc/xstring
index bf54308d3b..1947872cc2 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2674,7 +2674,7 @@ public:
             if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
                 _Construct<_Construct_strategy::_From_ptr>(
                     _UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
-            } else if constexpr (_Is_fwd_iter_v<decltype(_UFirst)>) {
+            } else if constexpr (_Is_cpp17_fwd_iter_v<decltype(_UFirst)>) {
                 const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
                 const auto _Count  = _Convert_size<size_type>(_Length);
                 _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast), _Count);

From 6eafabd1d862a44806f048c9e0c0f4f95d033f2b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:23:33 -0700
Subject: [PATCH 22/37] Rename to P1206R7_forward_list_insert_range_after.

---
 tests/std/test.lst                                              | 2 +-
 .../env.lst                                                     | 0
 .../test.cpp                                                    | 0
 3 files changed, 1 insertion(+), 1 deletion(-)
 rename tests/std/tests/{P1206R7_forward_list_insert_range => P1206R7_forward_list_insert_range_after}/env.lst (100%)
 rename tests/std/tests/{P1206R7_forward_list_insert_range => P1206R7_forward_list_insert_range_after}/test.cpp (100%)

diff --git a/tests/std/test.lst b/tests/std/test.lst
index 0013d43037..89a623e904 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -476,7 +476,7 @@ tests\P1206R7_deque_insert_range
 tests\P1206R7_deque_prepend_range
 tests\P1206R7_forward_list_assign_range
 tests\P1206R7_forward_list_from_range
-tests\P1206R7_forward_list_insert_range
+tests\P1206R7_forward_list_insert_range_after
 tests\P1206R7_forward_list_prepend_range
 tests\P1206R7_from_range
 tests\P1206R7_list_append_range
diff --git a/tests/std/tests/P1206R7_forward_list_insert_range/env.lst b/tests/std/tests/P1206R7_forward_list_insert_range_after/env.lst
similarity index 100%
rename from tests/std/tests/P1206R7_forward_list_insert_range/env.lst
rename to tests/std/tests/P1206R7_forward_list_insert_range_after/env.lst
diff --git a/tests/std/tests/P1206R7_forward_list_insert_range/test.cpp b/tests/std/tests/P1206R7_forward_list_insert_range_after/test.cpp
similarity index 100%
rename from tests/std/tests/P1206R7_forward_list_insert_range/test.cpp
rename to tests/std/tests/P1206R7_forward_list_insert_range_after/test.cpp

From cb3b81d681ec058398f0b4d8bceecd9f2ea83a9c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:24:24 -0700
Subject: [PATCH 23/37] Add `// Validate non-views` comments.

---
 tests/std/tests/P1206R7_deque_append_range/test.cpp         | 1 +
 tests/std/tests/P1206R7_deque_prepend_range/test.cpp        | 1 +
 tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp | 1 +
 tests/std/tests/P1206R7_list_append_range/test.cpp          | 1 +
 tests/std/tests/P1206R7_list_prepend_range/test.cpp         | 1 +
 tests/std/tests/P1206R7_priority_queue_push_range/test.cpp  | 1 +
 tests/std/tests/P1206R7_queue_push_range/test.cpp           | 1 +
 tests/std/tests/P1206R7_stack_push_range/test.cpp           | 1 +
 tests/std/tests/P1206R7_string_append_range/test.cpp        | 1 +
 tests/std/tests/P1206R7_string_assign_range/test.cpp        | 1 +
 tests/std/tests/P1206R7_vector_append_range/test.cpp        | 1 +
 11 files changed, 11 insertions(+)

diff --git a/tests/std/tests/P1206R7_deque_append_range/test.cpp b/tests/std/tests/P1206R7_deque_append_range/test.cpp
index c9a2a261c5..edf41e5f15 100644
--- a/tests/std/tests/P1206R7_deque_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_deque_append_range/test.cpp
@@ -79,6 +79,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_deque_prepend_range/test.cpp b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
index b91fcd46d1..9cdb600f47 100644
--- a/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_deque_prepend_range/test.cpp
@@ -78,6 +78,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
index b9933a4ee1..c26f49e08d 100644
--- a/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_forward_list_prepend_range/test.cpp
@@ -77,6 +77,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_list_append_range/test.cpp b/tests/std/tests/P1206R7_list_append_range/test.cpp
index afaa32b48b..d703adfdb9 100644
--- a/tests/std/tests/P1206R7_list_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_list_append_range/test.cpp
@@ -79,6 +79,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_list_prepend_range/test.cpp b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
index 13ad0df9bb..ff5d9e5478 100644
--- a/tests/std/tests/P1206R7_list_prepend_range/test.cpp
+++ b/tests/std/tests/P1206R7_list_prepend_range/test.cpp
@@ -78,6 +78,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
index e5166ce0c1..6b4d25b7b1 100644
--- a/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_priority_queue_push_range/test.cpp
@@ -94,6 +94,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_queue_push_range/test.cpp b/tests/std/tests/P1206R7_queue_push_range/test.cpp
index 781b43d569..af3f3be74e 100644
--- a/tests/std/tests/P1206R7_queue_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_queue_push_range/test.cpp
@@ -93,6 +93,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_stack_push_range/test.cpp b/tests/std/tests/P1206R7_stack_push_range/test.cpp
index d129b1747a..c91cf596f9 100644
--- a/tests/std/tests/P1206R7_stack_push_range/test.cpp
+++ b/tests/std/tests/P1206R7_stack_push_range/test.cpp
@@ -93,6 +93,7 @@ int main() {
     test_copyable_view();
     test_move_only_view();
 
+    // Validate non-views
     test_c_array();
     test_lvalue_vector();
     test_lvalue_forward_list();
diff --git a/tests/std/tests/P1206R7_string_append_range/test.cpp b/tests/std/tests/P1206R7_string_append_range/test.cpp
index edd929833a..127ce99cff 100644
--- a/tests/std/tests/P1206R7_string_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_string_append_range/test.cpp
@@ -119,6 +119,7 @@ int main() {
     test_move_only_view();
     STATIC_ASSERT(test_move_only_view());
 
+    // Validate non-views
     test_c_array();
     STATIC_ASSERT(test_c_array());
     test_lvalue_vector();
diff --git a/tests/std/tests/P1206R7_string_assign_range/test.cpp b/tests/std/tests/P1206R7_string_assign_range/test.cpp
index af273b55a4..7431a6eb26 100644
--- a/tests/std/tests/P1206R7_string_assign_range/test.cpp
+++ b/tests/std/tests/P1206R7_string_assign_range/test.cpp
@@ -114,6 +114,7 @@ int main() {
     test_move_only_view();
     STATIC_ASSERT(test_move_only_view());
 
+    // Validate non-views
     test_c_array();
     STATIC_ASSERT(test_c_array());
     test_lvalue_vector();
diff --git a/tests/std/tests/P1206R7_vector_append_range/test.cpp b/tests/std/tests/P1206R7_vector_append_range/test.cpp
index 39237770ab..0876a42639 100644
--- a/tests/std/tests/P1206R7_vector_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_append_range/test.cpp
@@ -155,6 +155,7 @@ int main() {
     test_move_only_view();
     STATIC_ASSERT(test_move_only_view());
 
+    // Validate non-views
     test_c_array();
     STATIC_ASSERT(test_c_array());
     test_lvalue_vector();

From d05cbd8690f0c9be9c38cb15b33abb180b274743 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:25:06 -0700
Subject: [PATCH 24/37] Reorder definitions: _UFirst then _ULast.

---
 stl/inc/deque | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index 7e28e64ce3..ed51e39aba 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -798,8 +798,8 @@ public:
         const auto _Oldsize = _Mysize();
         _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
         if constexpr (_RANGES bidirectional_range<_Rng>) {
-            auto _ULast        = _RANGES _Get_final_iterator_unwrapped(_Range);
             const auto _UFirst = _RANGES _Ubegin(_Range);
+            auto _ULast        = _RANGES _Get_final_iterator_unwrapped(_Range);
             while (_UFirst != _ULast) {
                 _Emplace_front_internal(*--_ULast); // prepend in order
             }

From 8ffc7801bfb77330228b58d428308280442e400b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:25:51 -0700
Subject: [PATCH 25/37] Reduce scope of clang-format suppression.

---
 stl/inc/ranges | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index cb3b1bfec2..03aa0e3599 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6715,21 +6715,22 @@ namespace ranges {
             { _Cont.capacity() } -> same_as<range_size_t<_Container>>;
             { _Cont.max_size() } -> same_as<range_size_t<_Container>>;
         };
+    // clang-format on
 
     template <class _Rng, class _Container>
     concept _Ref_converts = convertible_to<range_reference_t<_Rng>, range_value_t<_Container>>;
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Converts_direct_constructible = _Ref_converts<_Rng, _Container>
+    concept _Converts_direct_constructible = _Ref_converts<_Rng, _Container> //
         && constructible_from<_Container, _Rng, _Types...>;
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Converts_tag_constructible = _Ref_converts<_Rng, _Container>
+    concept _Converts_tag_constructible = _Ref_converts<_Rng, _Container> //
         && constructible_from<_Container, from_range_t, _Rng, _Types...>;
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Converts_and_common_constructible = _Ref_converts<_Rng, _Container> && common_range<_Rng>
-        && _Cpp17_input_iterator<iterator_t<_Rng>>
+    concept _Converts_and_common_constructible = _Ref_converts<_Rng, _Container> && common_range<_Rng> //
+        && _Cpp17_input_iterator<iterator_t<_Rng>> //
         && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
 
     template <class _Container, class _Reference>
@@ -6742,11 +6743,13 @@ namespace ranges {
         _Cont.insert(_Cont.end(), _STD declval<_Reference>());
     };
 
+    // clang-format off
     template <class _Rng, class _Container, class... _Types>
     concept _Converts_constructible_insertable = _Ref_converts<_Rng, _Container>
         && constructible_from<_Container, _Types...>
         && (_Can_push_back<_Container, range_reference_t<_Rng>>
             || _Can_insert_end<_Container, range_reference_t<_Rng>>);
+    // clang-format on
 
     template <class _Reference, class _Container>
     _NODISCARD constexpr auto _Container_inserter(_Container& _Cont) {
@@ -6757,6 +6760,7 @@ namespace ranges {
         }
     }
 
+    // clang-format off
     template <class _Container, input_range _Rng, class... _Types>
         requires (!view<_Container>)
     _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {

From bb956af0ef3b1d9405e8bc158921ddc2b1830f71 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:26:30 -0700
Subject: [PATCH 26/37] Change `std::` to `_STD`.

---
 stl/inc/ranges | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 03aa0e3599..5c754410b1 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6826,16 +6826,16 @@ namespace ranges {
 
     template <template <class...> class _Cnt, class _Rng, class... _Args>
     auto _To_helper() {
-        if constexpr (requires { _Cnt(std::declval<_Rng>(), std::declval<_Args>()...); }) {
-            return static_cast<decltype(_Cnt(std::declval<_Rng>(), std::declval<_Args>()...))*>(nullptr);
-        } else if constexpr (requires { _Cnt(from_range, std::declval<_Rng>(), std::declval<_Args>()...); }) {
-            return static_cast<decltype(_Cnt(from_range, std::declval<_Rng>(), std::declval<_Args>()...))*>(nullptr);
+        if constexpr (requires { _Cnt(_STD declval<_Rng>(), _STD declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(_STD declval<_Rng>(), _STD declval<_Args>()...))*>(nullptr);
+        } else if constexpr (requires { _Cnt(from_range, _STD declval<_Rng>(), _STD declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(from_range, _STD declval<_Rng>(), _STD declval<_Args>()...))*>(nullptr);
         } else if constexpr (requires {
-                                 _Cnt(std::declval<_Phony_input_iterator<_Rng>>(),
-                                     std::declval<_Phony_input_iterator<_Rng>>(), std::declval<_Args>()...);
+                                 _Cnt(_STD declval<_Phony_input_iterator<_Rng>>(),
+                                     _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Args>()...);
                              }) {
-            return static_cast<decltype(_Cnt(std::declval<_Phony_input_iterator<_Rng>>(),
-                std::declval<_Phony_input_iterator<_Rng>>(), std::declval<_Args>()...))*>(nullptr);
+            return static_cast<decltype(_Cnt(_STD declval<_Phony_input_iterator<_Rng>>(),
+                _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Args>()...))*>(nullptr);
         }
     }
 

From 764151428a13f7577c84e35cca3fb46f614fa149 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:27:02 -0700
Subject: [PATCH 27/37] Qualify `_RANGES to`.

---
 stl/inc/ranges | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 5c754410b1..5e9b3b58cc 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6842,7 +6842,7 @@ namespace ranges {
     template <template <class...> class _Container, input_range _Rng, class... _Types,
         class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
     _NODISCARD constexpr _Deduced to(_Rng&& _Range, _Types&&... _Args) {
-        return to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
     }
 
     template <template <class...> class _Container>

From d424e801e8f7090ef2d9c9f4c6619128012afe99 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:27:32 -0700
Subject: [PATCH 28/37] Simplify how access control interacts with ifdefs.

---
 stl/inc/vector | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 1c45c34220..6fa48f3dcd 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -1012,8 +1012,10 @@ private:
             _Orphan_range(_Oldlast, _Oldlast);
         }
     }
+#endif // __cpp_lib_containers_ranges
 
 public:
+#ifdef __cpp_lib_containers_ranges
     template <_Container_compatible_range<_Ty> _Rng>
     constexpr void append_range(_Rng&& _Range) {
         if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
@@ -1026,7 +1028,6 @@ public:
     }
 #endif // __cpp_lib_containers_ranges
 
-public:
     template <class... _Valty>
     _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
         // insert by perfectly forwarding _Val at _Where

From 7883bd454272e96147bb12bb66ab871e5bb185b2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:28:28 -0700
Subject: [PATCH 29/37] Fix comments.

---
 stl/inc/xmemory  | 2 +-
 stl/inc/xstring  | 6 +++---
 stl/inc/xutility | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index d01f79b05c..938d759de1 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -1715,7 +1715,7 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
 template <class _InIt, class _Alloc>
 _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy_n(
     _InIt _First, size_t _Count, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
-    // copy _First +[0, _Count) to raw _Dest, using _Al
+    // copy _First + [0, _Count) to raw _Dest, using _Al
     // note: only called internally from elsewhere in the STL
     using _Ptrval = typename _Alloc::value_type*;
 
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 1947872cc2..41d55f0e87 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2757,7 +2757,7 @@ private:
     template <class _Iter, class _Sent, class _Size = nullptr_t>
     _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
         // Pre: _First models input_iterator or meets the Cpp17InputIterator requirements
-        // Pre: [_First, Last) is a valid range
+        // Pre: [_First, _Last) is a valid range
         // Pre: if is_same_v<_Size, size_type>, _Count is the length of [_First, _Last).
         // Pre: *this is in SSO mode; the lifetime of the SSO elements has already begun
 
@@ -3818,8 +3818,8 @@ public:
 
         const size_type _Growth = static_cast<size_type>(_Count - _Nx);
 
-        // checking for overlapping ranges is technically UB (considering string literals), so just always
-        // reallocate and copy to the new buffer if constant evaluated
+        // checking for overlapping ranges is technically UB (considering string literals), so just always reallocate
+        // and copy to the new buffer if constant evaluated
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 203b564fab..f10c185040 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -3729,7 +3729,7 @@ using _Sent_copy_cat = conditional_t<
     is_same_v<_Sent, _InIt> || sized_sentinel_for<_Sent, _InIt>,
 #else // ^^^ Concepts support / no Concepts vvv
     is_same_v<_Sent, _InIt>,
-#endif
+#endif // ^^^ no Concepts ^^^
     _Iter_copy_cat<_InIt, _OutIt>, _False_trivial_cat>;
 
 template <class _InIt, class _Sent, class _OutIt>

From 371deba81d2c9cfc24b000b13677c860b7e8508b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:29:03 -0700
Subject: [PATCH 30/37] Avoid redundant namespace alias.

---
 tests/std/tests/P1206R7_ranges_to/test.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/std/tests/P1206R7_ranges_to/test.cpp b/tests/std/tests/P1206R7_ranges_to/test.cpp
index 132f7fe664..27c0a97c1b 100644
--- a/tests/std/tests/P1206R7_ranges_to/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to/test.cpp
@@ -21,8 +21,6 @@
 
 using namespace std::literals;
 
-namespace ranges = std::ranges;
-
 template <class T>
 struct myalloc {
     using value_type = T;

From b983211641b7f2ec05fec33cbad1d7e8ec89766a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:29:37 -0700
Subject: [PATCH 31/37] constexpr string/vector are always available, reported
 VSO-1588614.

---
 tests/std/tests/P1206R7_ranges_to/test.cpp | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/tests/std/tests/P1206R7_ranges_to/test.cpp b/tests/std/tests/P1206R7_ranges_to/test.cpp
index 27c0a97c1b..d6bf834fbc 100644
--- a/tests/std/tests/P1206R7_ranges_to/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to/test.cpp
@@ -160,12 +160,8 @@ struct sequence_instantiator {
         test_sequence<R, std::list>();
         test_sequence<R, std::vector>();
 
-#ifdef __cpp_lib_constexpr_string
         static_assert(test_sequence<R, std::basic_string>());
-#endif // __cpp_lib_constexpr_string
-#ifdef __cpp_lib_constexpr_vector
         static_assert(test_sequence<R, std::vector>());
-#endif // __cpp_lib_constexpr_vector
     }
 };
 
@@ -584,12 +580,8 @@ int main() {
     sequence_instantiator::test_copy_move<std::forward_list>();
     sequence_instantiator::test_copy_move<std::list>();
     sequence_instantiator::test_copy_move<std::vector>();
-#ifdef __cpp_lib_constexpr_string
     static_assert(sequence_instantiator::test_copy_move<std::basic_string>());
-#endif // __cpp_lib_constexpr_string
-#ifdef __cpp_lib_constexpr_vector
     static_assert(sequence_instantiator::test_copy_move<std::vector>());
-#endif // __cpp_lib_constexpr_vector
 
     mappish_instantiator::test_copy_move<std::map>();
     mappish_instantiator::test_copy_move<std::multimap>();
@@ -608,7 +600,7 @@ int main() {
     static_assert(test_common_constructible());
 
     test_nested_range();
-#if defined(__cpp_lib_constexpr_vector) && (defined(__clang__) || defined(__EDG__))
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1588614
     static_assert(test_nested_range());
-#endif // defined(__cpp_lib_constexpr_vector) && (defined(__clang__) || defined(__EDG__))
+#endif // defined(__clang__) || defined(__EDG__)
 }

From e9c4a4e811e32f3029045a59fd3f627cf4f83332 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:30:25 -0700
Subject: [PATCH 32/37] Avoid redundant `constexpr const`.

---
 tests/std/tests/P1206R7_string_from_range/test.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/std/tests/P1206R7_string_from_range/test.cpp b/tests/std/tests/P1206R7_string_from_range/test.cpp
index 494a258b4e..b94a62dc32 100644
--- a/tests/std/tests/P1206R7_string_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_string_from_range/test.cpp
@@ -41,8 +41,8 @@ constexpr bool test_string(Rng&& rng, const T* expected) {
     return true;
 }
 
-static constexpr const char hw[]    = "Hello, world!";
-static constexpr const auto span_hw = span{hw}.first<span{hw}.size() - 1>();
+static constexpr char hw[]    = "Hello, world!";
+static constexpr auto span_hw = span{hw}.first<span{hw}.size() - 1>();
 
 struct string_instantiator {
     template <ranges::input_range R>
@@ -52,8 +52,8 @@ struct string_instantiator {
     }
 };
 
-static constexpr const wchar_t whw[] = L"Hello, world!";
-static constexpr const auto span_whw = span{whw}.first<span{whw}.size() - 1>();
+static constexpr wchar_t whw[] = L"Hello, world!";
+static constexpr auto span_whw = span{whw}.first<span{whw}.size() - 1>();
 
 struct wstring_instantiator {
     template <ranges::input_range R>

From b9d8186178ddf29a33e838f179d710db4b3c177c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:30:53 -0700
Subject: [PATCH 33/37] Drop unnecessary `std::` in tests.

---
 tests/std/tests/P1206R7_vector_append_range/test.cpp | 2 +-
 tests/std/tests/P1206R7_vector_assign_range/test.cpp | 2 +-
 tests/std/tests/P1206R7_vector_from_range/test.cpp   | 2 +-
 tests/std/tests/P1206R7_vector_insert_range/test.cpp | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/std/tests/P1206R7_vector_append_range/test.cpp b/tests/std/tests/P1206R7_vector_append_range/test.cpp
index 0876a42639..80a1d04eff 100644
--- a/tests/std/tests/P1206R7_vector_append_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_append_range/test.cpp
@@ -60,7 +60,7 @@ constexpr bool test_vector_bool(const size_t capacity, const size_t presize, Rng
     vec.append_range(forward<Rng>(rng));
     const auto length = static_cast<ptrdiff_t>(presize);
     assert(ranges::count(vec | views::take(length), true) == length);
-    assert(ranges::equal(vec | views::drop(length), expected, std::equal_to<bool>{}));
+    assert(ranges::equal(vec | views::drop(length), expected, equal_to<bool>{}));
 
     return true;
 }
diff --git a/tests/std/tests/P1206R7_vector_assign_range/test.cpp b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
index af2b35ed68..45bf68d4e6 100644
--- a/tests/std/tests/P1206R7_vector_assign_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_assign_range/test.cpp
@@ -43,7 +43,7 @@ template <ranges::input_range Rng, ranges::random_access_range Expected>
 constexpr bool test_vector_bool(const size_t presize, Rng&& rng, Expected&& expected) {
     vector<bool> vec(presize, true);
     vec.assign_range(forward<Rng>(rng));
-    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+    assert(ranges::equal(vec, expected, equal_to<bool>{}));
 
     return true;
 }
diff --git a/tests/std/tests/P1206R7_vector_from_range/test.cpp b/tests/std/tests/P1206R7_vector_from_range/test.cpp
index 465623e734..f48604bae2 100644
--- a/tests/std/tests/P1206R7_vector_from_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_from_range/test.cpp
@@ -35,7 +35,7 @@ struct vector_instantiator {
 template <ranges::input_range Rng, ranges::random_access_range Expected>
 constexpr bool test_vector_bool(Rng&& rng, Expected&& expected) {
     vector<bool> vec(from_range, forward<Rng>(rng));
-    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+    assert(ranges::equal(vec, expected, equal_to<bool>{}));
 
     return true;
 }
diff --git a/tests/std/tests/P1206R7_vector_insert_range/test.cpp b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
index 6b9b7a9100..185a7d0f02 100644
--- a/tests/std/tests/P1206R7_vector_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
@@ -49,7 +49,7 @@ constexpr bool test_vector_bool(const size_t presize, Rng&& rng, Expected&& expe
     const same_as<vector<bool>::iterator> auto result =
         vec.insert_range(ranges::next(vec.begin(), presize != 0), forward<Rng>(rng));
     assert(result == ranges::next(vec.begin(), presize != 0));
-    assert(ranges::equal(vec, expected, std::equal_to<bool>{}));
+    assert(ranges::equal(vec, expected, equal_to<bool>{}));
 
     return true;
 }

From a4932c5ed6571c372e265639ce319cbdc9e2c778 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:31:27 -0700
Subject: [PATCH 34/37] Use `bool` for expected arrays.

---
 tests/std/tests/P1206R7_vector_insert_range/test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/P1206R7_vector_insert_range/test.cpp b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
index 185a7d0f02..08333f8011 100644
--- a/tests/std/tests/P1206R7_vector_insert_range/test.cpp
+++ b/tests/std/tests/P1206R7_vector_insert_range/test.cpp
@@ -54,15 +54,15 @@ constexpr bool test_vector_bool(const size_t presize, Rng&& rng, Expected&& expe
     return true;
 }
 
-static constexpr int other_ints[80]       = { //
+static constexpr int other_ints[80]        = { //
     0, 7, 0, 2, 3, 0, 0, 0, 4, 0, 0, 2, 5, 1, 0, 7, //
     6, 3, 0, 7, 0, 5, 7, 0, 3, 4, 5, 0, 3, 0, 0, 2, //
     2, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 5, 0, 0, 0, //
     0, 4, 2, 4, 0, 7, 0, 2, 0, 7, 1, 0, 6, 0, 0, 6, //
     3, 5, 0, 7, 0, 7, 0, 0, 2, 3, 5, 2, 2, 0, 7, 3};
-static constexpr int other_short_result[] = {true, false, true, true, true, true, true, true, true, true, true, true,
+static constexpr bool other_short_result[] = {true, false, true, true, true, true, true, true, true, true, true, true,
     true}; // result of inserting other_ints at offset 1 in a sequence of 5 trues
-static constexpr int other_long_result[]  = {true, false, true, true, true, true, true, true, true, true, true, true,
+static constexpr bool other_long_result[]  = {true, false, true, true, true, true, true, true, true, true, true, true,
      true, true, true, true, true, true, true}; // ditto, in a sequence of 11 trues
 
 struct vector_boo_instantiator {

From 5582f29a8e78b4b9845710077053ac08a681b6d3 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Aug 2022 02:32:11 -0700
Subject: [PATCH 35/37] Apply `defined(__cpp_lib_concepts)` cleanup.

---
 .../tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 7285ea489a..24f392c1b8 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -662,7 +662,7 @@ STATIC_ASSERT(__cpp_lib_constexpr_vector == 201907L);
 #endif
 #endif
 
-#if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support and GH-1814
+#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
 #ifndef __cpp_lib_containers_ranges
 #error __cpp_lib_containers_ranges is not defined
 #elif __cpp_lib_containers_ranges != 202202L

From 4c9dc790438911beeec83489bc68008b20c6a72c Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Mon, 8 Aug 2022 11:51:21 -0700
Subject: [PATCH 36/37] Chack construction from `const from_range_t&` instead
 of `from_range_t`

... per resolution of just-submitted LWG issue.
---
 stl/inc/ranges | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 5e9b3b58cc..ea7ea2c5a3 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6725,8 +6725,9 @@ namespace ranges {
         && constructible_from<_Container, _Rng, _Types...>;
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Converts_tag_constructible = _Ref_converts<_Rng, _Container> //
-        && constructible_from<_Container, from_range_t, _Rng, _Types...>;
+    concept _Converts_tag_constructible = _Ref_converts<_Rng, _Container>
+        // per LWG issue unnumbered as of 2022-08-08
+        && constructible_from<_Container, const from_range_t&, _Rng, _Types...>;
 
     template <class _Rng, class _Container, class... _Types>
     concept _Converts_and_common_constructible = _Ref_converts<_Rng, _Container> && common_range<_Rng> //

From d2cc9edd25984710675b41eeb6fd68df8e77ea2b Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Mon, 8 Aug 2022 19:24:41 -0700
Subject: [PATCH 37/37] `_Copy_n_unchecked` is a zombie

---
 stl/inc/vector                                     | 4 ++--
 stl/inc/xutility                                   | 2 +-
 tests/std/tests/P0784R7_library_machinery/test.cpp | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 6fa48f3dcd..9689a5862c 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -1485,7 +1485,7 @@ private:
             }
         } else {
             const pointer _Newlast = _Myfirst + _Newsize;
-            _Copy_n_unchecked(_STD move(_First), _Newsize, _Myfirst);
+            _Copy_n_unchecked4(_STD move(_First), _Newsize, _Myfirst);
             _Destroy_range(_Newlast, _Mylast, _Al);
             _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
             _Mylast = _Newlast;
@@ -3425,7 +3425,7 @@ public:
             const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
             const auto _Count  = _Convert_size<size_type>(_Length);
             const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
-            _Copy_n_unchecked(_RANGES _Ubegin(_Range), _Count, begin() + _Off);
+            _Copy_n_unchecked4(_RANGES _Ubegin(_Range), _Count, begin() + _Off);
         } else {
             auto _UFirst      = _RANGES _Ubegin(_Range);
             const auto _ULast = _RANGES _Uend(_Range);
diff --git a/stl/inc/xutility b/stl/inc/xutility
index f10c185040..36cc94d3c8 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -3700,7 +3700,7 @@ template <class _It, bool _RequiresMutable = false>
 _INLINE_VAR constexpr bool _Is_vb_iterator = false;
 
 template <class _InIt, class _SizeTy, class _OutIt>
-_CONSTEXPR20 _OutIt _Copy_n_unchecked(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
+_CONSTEXPR20 _OutIt _Copy_n_unchecked4(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
     // copy _First + [0, _Count) to _Dest + [0, _Count), returning _Dest + _Count
     // note: has callers outside the copy family
 #ifdef __cpp_lib_concepts
diff --git a/tests/std/tests/P0784R7_library_machinery/test.cpp b/tests/std/tests/P0784R7_library_machinery/test.cpp
index 4968462de8..1e2864a316 100644
--- a/tests/std/tests/P0784R7_library_machinery/test.cpp
+++ b/tests/std/tests/P0784R7_library_machinery/test.cpp
@@ -64,11 +64,11 @@ constexpr bool test() {
         assert(equal(begin(expected_copy), end(expected_copy), begin(output), end(output)));
     }
 
-    { // _Copy_n_unchecked
+    { // _Copy_n_unchecked4
         int_wrapper_copy input[]   = {1, 2, 3, 4};
         int_wrapper_copy output[4] = {5, 6, 7, 8};
 
-        const auto result = _Copy_n_unchecked(begin(input), size(input), begin(output));
+        const auto result = _Copy_n_unchecked4(begin(input), size(input), begin(output));
         static_assert(is_same_v<remove_const_t<decltype(result)>, int_wrapper_copy*>);
         assert(result == end(output));
         assert(equal(begin(expected_copy), end(expected_copy), begin(output), end(output)));