diff --git a/include/sg14/flat_map.h b/include/sg14/flat_map.h
index ff1737e..2d5e29e 100644
--- a/include/sg14/flat_map.h
+++ b/include/sg14/flat_map.h
@@ -34,6 +34,7 @@
 #include <functional>
 #include <initializer_list>
 #include <iterator>
+#include <utility>
 #include <vector>
 
 #if __cplusplus >= 202002L
@@ -50,12 +51,6 @@
 namespace sg14 {
 
 namespace flatmap_detail {
-    template<class T, class = void> struct qualifies_as_range : std::false_type {};
-    template<class T> struct qualifies_as_range<T, decltype(
-        std::begin( std::declval<T()>()() ), void(),
-        std::end( std::declval<T()>()() ), void()
-    )> : std::true_type {};
-
     template<class It>
     using is_random_access_iterator = std::is_convertible<
         typename std::iterator_traits<It>::iterator_category,
@@ -93,12 +88,6 @@ namespace flatmap_detail {
         return make_obj_using_allocator_<T>(priority_tag<3>(), alloc, static_cast<Args&&>(args)...);
     }
 
-    template<class Container>
-    using cont_key_type = typename std::remove_const<typename Container::value_type::first_type>::type;
-
-    template<class Container>
-    using cont_mapped_type = typename Container::value_type::second_type;
-
     template<class InputIterator>
     using iter_key_type = typename std::remove_const<typename std::iterator_traits<InputIterator>::value_type::first_type>::type;
 
@@ -176,7 +165,7 @@ namespace flatmap_detail {
     }
 
     template<class It, class It2, class Compare>
-    It unique_helper(It first, It last, It2 mapped, Compare& compare) {
+    It unique_helper(It first, It last, It2 mapped, const Compare& compare) {
         It dfirst = first;
         It2 dmapped = mapped;
         while (first != last) {
@@ -199,6 +188,20 @@ namespace flatmap_detail {
         return dfirst;
     }
 
+    template<class FS>
+    struct InvariantRestoringGuard {
+        FS *self_;
+        explicit InvariantRestoringGuard(FS *self) : self_(self) {}
+        void complete() {
+            self_ = nullptr;
+        }
+        ~InvariantRestoringGuard() {
+            if (self_ != nullptr) {
+                self_->clear();
+            }
+        }
+    };
+
     template<class, class> class iter;
     template<class K, class V> iter<K, V> make_iterator(K, V);
 
@@ -215,7 +218,7 @@ namespace flatmap_detail {
     class iter {
     public:
         using difference_type = ptrdiff_t;
-        using value_type = std::pair<const typename std::iterator_traits<KeyIt>::value_type, typename std::iterator_traits<MappedIt>::value_type>;
+        using value_type = std::pair<typename std::iterator_traits<KeyIt>::value_type, typename std::iterator_traits<MappedIt>::value_type>;
         using reference = std::pair<typename std::iterator_traits<KeyIt>::reference, typename std::iterator_traits<MappedIt>::reference>;
         using pointer = arrow_proxy<reference>;
         using iterator_category = std::random_access_iterator_tag;
@@ -241,6 +244,18 @@ namespace flatmap_detail {
             return arrow_proxy<reference>{reference{*kit_, *vit_}};
         }
 
+        friend auto iter_move(const iter& it) {
+#if __cpp_lib_ranges >= 201911L
+            using K = decltype(std::ranges::iter_move(it.kit_));
+            using V = decltype(std::ranges::iter_move(it.vit_));
+            return std::pair<K, V>(std::ranges::iter_move(it.kit_), std::ranges::iter_move(it.vit_));
+#else
+            using K = decltype(std::move(*it.kit_));
+            using V = decltype(std::move(*it.vit_));
+            return std::pair<K, V>(std::move(*it.kit_), std::move(*it.vit_));
+#endif
+        }
+
         iter& operator++() { ++kit_; ++vit_; return *this; }
         iter& operator--() { --kit_; --vit_; return *this; }
         iter operator++(int) { iter result(*this); ++*this; return result; }
@@ -331,17 +346,13 @@ class flat_map {
     using key_container_type = KeyContainer;
     using mapped_container_type = MappedContainer;
 
-    class value_compare {
-        friend class flat_map;
-    protected:
-        // TODO: this should be private
-        Compare comp;
-        // TODO: this constructor should be explicit
-        value_compare(Compare c): comp(c) {}
-    public:
+    struct value_compare {
+        explicit value_compare(Compare c): comp_(std::move(c)) {}
         bool operator()(const_reference x, const_reference y) const {
-            return comp(x.first, y.first);
+            return comp_(x.first, y.first);
         }
+    private:
+        Compare comp_;
     };
 
     struct containers {
@@ -354,77 +365,6 @@ class flat_map {
 
     flat_map() = default;
 
-    flat_map(KeyContainer keys, MappedContainer values)
-        : keys_(static_cast<KeyContainer&&>(keys)), values_(static_cast<MappedContainer&&>(values))
-    {
-        this->sort_and_unique_impl();
-    }
-
-    template<class Alloc,
-             typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(KeyContainer keys, MappedContainer values, const Alloc& a)
-        : keys_(flatmap_detail::make_obj_using_allocator<KeyContainer>(a, std::move(keys))), 
-          values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a, std::move(values)))
-    {
-        this->sort_and_unique_impl();
-    }
-
-    template<class Container,
-             typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value, int>::type = 0>
-    explicit flat_map(const Container& cont)
-        : flat_map(std::begin(cont), std::end(cont), Compare()) {}
-
-    template<class Container,
-             typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value, int>::type = 0>
-    explicit flat_map(const Container& cont, const Compare& comp)
-        : flat_map(std::begin(cont), std::end(cont), comp) {}
-
-    template<class Container, class Alloc,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<MappedContainer, Alloc>::value>::type>
-    flat_map(const Container& cont, const Alloc& a)
-        : flat_map(std::begin(cont), std::end(cont), Compare(), a) {}
-
-    template<class Container, class Alloc,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<MappedContainer, Alloc>::value>::type>
-    flat_map(const Container& cont, const Compare& comp, const Alloc& a)
-        : flat_map(std::begin(cont), std::end(cont), comp, a) {}
-
-    flat_map(sorted_unique_t, KeyContainer keys, MappedContainer values)
-        : keys_(static_cast<KeyContainer&&>(keys)), values_(static_cast<MappedContainer&&>(values)) {}
-
-    template<class Alloc,
-             typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(sorted_unique_t s, KeyContainer keys, MappedContainer values, const Alloc& a)
-        : flat_map(s, KeyContainer(static_cast<KeyContainer&&>(keys), a), MappedContainer(static_cast<MappedContainer&&>(values), a)) {}
-
-    template<class Container,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type>
-    flat_map(sorted_unique_t s, const Container& cont)
-        : flat_map(s, std::begin(cont), std::end(cont), Compare()) {}
-
-    template<class Container,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type>
-    flat_map(sorted_unique_t s, const Container& cont, const Compare& comp)
-        : flat_map(s, std::begin(cont), std::end(cont), comp) {}
-
-    template<class Container, class Alloc,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<MappedContainer, Alloc>::value>::type>
-    flat_map(sorted_unique_t s, const Container& cont, const Alloc& a)
-        : flat_map(s, std::begin(cont), std::end(cont), Compare(), a) {}
-
-    template<class Container, class Alloc,
-             class = typename std::enable_if<flatmap_detail::qualifies_as_range<const Container&>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type,
-             class = typename std::enable_if<std::uses_allocator<MappedContainer, Alloc>::value>::type>
-    flat_map(sorted_unique_t s, const Container& cont, const Compare& comp, const Alloc& a)
-        : flat_map(s, std::begin(cont), std::end(cont), comp, a) {}
-
     explicit flat_map(const Compare& comp)
         : compare_(comp) {}
 
@@ -440,18 +380,52 @@ class flat_map {
     explicit flat_map(const Alloc& a)
         : flat_map(Compare(), a) {}
 
-    // TODO: shouldn't InputIterator be constrained to point to something with "first" and "second" members?
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
+    template<std::ranges::input_range R>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type>
+    flat_map(std::from_range_t, R&& rg)
+    {
+        this->insert_range(static_cast<R&&>(rg));
+    }
+
+    template<std::ranges::input_range R, class Alloc>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type> &&
+                 std::uses_allocator_v<KeyContainer, Alloc> &&
+                 std::uses_allocator_v<MappedContainer, Alloc>
+    flat_map(std::from_range_t, R&& rg, const Alloc& a)
+        : keys_(flatmap_detail::make_obj_using_allocator<KeyContainer>(a)),
+          values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a))
+    {
+        this->insert_range(static_cast<R&&>(rg));
+    }
+
+    template<std::ranges::input_range R>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type>
+    flat_map(std::from_range_t, R&& rg, const Compare& comp)
+        : compare_(comp)
+    {
+        this->insert_range(static_cast<R&&>(rg));
+    }
+
+    template<std::ranges::input_range R, class Alloc>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type> &&
+                 std::uses_allocator_v<KeyContainer, Alloc> &&
+                 std::uses_allocator_v<MappedContainer, Alloc>
+    flat_map(std::from_range_t, R&& rg, const Compare& comp, const Alloc& a)
+        : keys_(flatmap_detail::make_obj_using_allocator<KeyContainer>(a)),
+          values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a)),
+          compare_(comp)
+    {
+        this->insert_range(static_cast<R&&>(rg));
+    }
+#endif // __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
+
     template<class InputIterator,
              class = typename std::enable_if<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value>::type>
     flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare())
         : compare_(comp)
     {
-        for (; first != last; ++first) {
-            keys_.insert(keys_.end(), first->first);
-            // TODO: we must make this exception-safe if the container insert throws
-            values_.insert(values_.end(), first->second);
-        }
-        this->sort_and_unique_impl();
+        this->insert(first, last);
     }
 
     template<class InputIterator, class Alloc,
@@ -463,11 +437,7 @@ class flat_map {
           values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a)),
           compare_(comp)
     {
-        for (; first != last; ++first) {
-            keys_.insert(keys_.end(), first->first);
-            values_.insert(values_.end(), first->second);
-        }
-        this->sort_and_unique_impl();
+        this->insert(first, last);
     }
 
     template<class InputIterator, class Alloc,
@@ -482,10 +452,7 @@ class flat_map {
     flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Compare& comp = Compare())
         : compare_(comp)
     {
-        for (; first != last; ++first) {
-            keys_.insert(keys_.end(), first->first);
-            values_.insert(values_.end(), first->second);
-        }
+        this->insert(sorted_unique, first, last);
     }
 
     template<class InputIterator, class Alloc,
@@ -497,10 +464,7 @@ class flat_map {
           values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a)),
           compare_(comp)
     {
-        for (; first != last; ++first) {
-            keys_.insert(keys_.end(), first->first);
-            values_.insert(values_.end(), first->second);
-        }
+        this->insert(sorted_unique, first, last);
     }
 
     template<class InputIterator, class Alloc,
@@ -510,7 +474,6 @@ class flat_map {
     flat_map(sorted_unique_t s, InputIterator first, InputIterator last, const Alloc& a)
         : flat_map(s, first, last, Compare(), a) {}
 
-    // TODO: should this be conditionally noexcept?
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
     flat_map(flat_map&& m, const Alloc& a)
@@ -525,7 +488,10 @@ class flat_map {
           values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a, m.values_)),
           compare_(m.compare_) {}
 
-    flat_map(std::initializer_list<value_type> il, const Compare& comp = Compare())
+    flat_map(std::initializer_list<value_type> il)
+        : flat_map(il.begin(), il.end()) {}
+
+    flat_map(std::initializer_list<value_type> il, const Compare& comp)
         : flat_map(il.begin(), il.end(), comp) {}
 
     template<class Alloc,
@@ -536,7 +502,7 @@ class flat_map {
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
     flat_map(std::initializer_list<value_type> il, const Alloc& a)
-        : flat_map(il.begin(), il.end(), a) {}
+        : flat_map(il.begin(), il.end(), Compare(), a) {}
 
     flat_map(sorted_unique_t s, std::initializer_list<value_type> il, const Compare& comp = Compare())
         : flat_map(s, il.begin(), il.end(), comp) {}
@@ -555,7 +521,7 @@ class flat_map {
 
     flat_map& operator=(std::initializer_list<value_type> il) {
         this->clear();
-        this->insert(il);
+        this->insert(il.begin(), il.end());
         return *this;
     }
 
@@ -693,39 +659,76 @@ class flat_map {
         this->insert(s, il.begin(), il.end());
     }
 
-    containers extract() && {
-        try {
-            containers result{
-                static_cast<KeyContainer&&>(keys_),
-                static_cast<MappedContainer&&>(values_)
-            };
-            this->clear();
-            return result;
-        } catch (...) {
-            this->clear();
-            throw;
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
+    template<std::ranges::input_range R>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type>
+    void insert_range(R&& rg) {
+        flatmap_detail::InvariantRestoringGuard<flat_map> guard(this);
+        size_type oldsize = keys_.size();
+        for (value_type e : rg) {
+            keys_.emplace_back(std::move(e.first));
+            values_.emplace_back(std::move(e.second));
         }
+        if (keys_.size() != oldsize) {
+            auto begin = flatmap_detail::make_iterator(keys_.begin(), values_.begin());
+            auto mid = begin + oldsize;
+            auto end = flatmap_detail::make_iterator(keys_.end(), values_.end());
+            std::ranges::sort(mid, end, value_comp());
+            std::ranges::inplace_merge(begin, mid, end, value_comp());
+            auto kit = flatmap_detail::unique_helper(keys_.begin(), keys_.end(), values_.begin(), compare_);
+            auto vit = values_.begin() + (kit - keys_.begin());
+            keys_.erase(kit, keys_.end());
+            values_.erase(vit, values_.end());
+        }
+        guard.complete();
     }
 
-    void replace(KeyContainer keys, MappedContainer values) {
-        try {
-            keys_ = static_cast<KeyContainer&&>(keys);
-            values_ = static_cast<MappedContainer&&>(values);
-            this->sort_and_unique_impl();
-        } catch (...) {
-            this->clear();
-            throw;
+    template<std::ranges::input_range R>
+        requires std::convertible_to<std::ranges::range_reference_t<R>, value_type>
+    void insert_range(sg14::sorted_unique_t, R&& rg) {
+        flatmap_detail::InvariantRestoringGuard<flat_map> guard(this);
+        size_type oldsize = keys_.size();
+        for (value_type e : rg) {
+            keys_.emplace_back(std::move(e.first));
+            values_.emplace_back(std::move(e.second));
+        }
+        if (keys_.size() != oldsize) {
+            auto begin = flatmap_detail::make_iterator(keys_.begin(), values_.begin());
+            auto mid = begin + oldsize;
+            auto end = flatmap_detail::make_iterator(keys_.end(), values_.end());
+            std::ranges::inplace_merge(begin, mid, end, compare_);
+            auto kit = flatmap_detail::unique_helper(keys_.begin(), keys_.end(), values_.begin(), compare_);
+            auto vit = values_.begin() + (kit - keys_.begin());
+            keys_.erase(kit, keys_.end());
+            values_.erase(vit, values_.end());
         }
+        guard.complete();
+    }
+#endif
+
+    containers extract() && {
+        flatmap_detail::InvariantRestoringGuard<flat_map> guard(this);
+        containers result{
+            static_cast<KeyContainer&&>(keys_),
+            static_cast<MappedContainer&&>(values_)
+        };
+        // Deliberately do not complete the guard.
+        return result;
+    }
+
+    void replace(KeyContainer keys, MappedContainer values) {
+        flatmap_detail::InvariantRestoringGuard<flat_map> guard(this);
+        keys_ = static_cast<KeyContainer&&>(keys);
+        values_ = static_cast<MappedContainer&&>(values);
+        this->sort_and_unique_impl();
+        guard.complete();
     }
 
     void replace(sorted_unique_t, KeyContainer keys, MappedContainer values) {
-        try {
-            keys_ = static_cast<KeyContainer&&>(keys);
-            values_ = static_cast<MappedContainer&&>(values);
-        } catch (...) {
-            this->clear();
-            throw;
-        }
+        flatmap_detail::InvariantRestoringGuard<flat_map> guard(this);
+        keys_ = static_cast<KeyContainer&&>(keys);
+        values_ = static_cast<MappedContainer&&>(values);
+        guard.complete();
     }
 
     template<class... Args>
@@ -1118,120 +1121,31 @@ class flat_map {
 
 #if defined(__cpp_deduction_guides)
 
-// TODO: this deduction guide should maybe be constrained by qualifies_as_range
-template<class Container,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Container>::value>>
-flat_map(Container)
-    -> flat_map<flatmap_detail::cont_key_type<Container>, flatmap_detail::cont_mapped_type<Container>>;
-
-template<class KeyContainer, class MappedContainer,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<KeyContainer>::value && !flatmap_detail::qualifies_as_allocator<MappedContainer>::value>>
-flat_map(KeyContainer, MappedContainer)
-    -> flat_map<typename KeyContainer::value_type,
-                typename MappedContainer::value_type,
-                std::less<typename KeyContainer::value_type>,
-                KeyContainer, MappedContainer>;
-
-// TODO: all these deduction guides that ignore the Allocator parameter are wrong, but especially this one
-template<class Container, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Container>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value && std::uses_allocator<Container, Allocator>::value>>
-flat_map(Container, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<flatmap_detail::cont_key_type<Container>, flatmap_detail::cont_mapped_type<Container>>;
-
-template<class KeyContainer, class MappedContainer, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<KeyContainer>::value && !flatmap_detail::qualifies_as_allocator<MappedContainer>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value && std::uses_allocator<KeyContainer, Allocator>::value && std::uses_allocator<MappedContainer, Allocator>::value>>
-flat_map(KeyContainer, MappedContainer, Allocator)
-    -> flat_map<typename KeyContainer::value_type,
-                typename MappedContainer::value_type,
-                std::less<typename KeyContainer::value_type>,
-                KeyContainer, MappedContainer>;
-
-template<class Container,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Container>::value>>
-flat_map(sorted_unique_t, Container)
-    -> flat_map<flatmap_detail::cont_key_type<Container>, flatmap_detail::cont_mapped_type<Container>>;
-
-template<class KeyContainer, class MappedContainer,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<KeyContainer>::value && !flatmap_detail::qualifies_as_allocator<MappedContainer>::value>>
-flat_map(sorted_unique_t, KeyContainer, MappedContainer)
-    -> flat_map<typename KeyContainer::value_type,
-                typename MappedContainer::value_type,
-                std::less<typename KeyContainer::value_type>,
-                KeyContainer, MappedContainer>;
-
-template<class Container, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Container>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value && std::uses_allocator<Container, Allocator>::value>>
-flat_map(sorted_unique_t, Container, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<flatmap_detail::cont_key_type<Container>, flatmap_detail::cont_mapped_type<Container>>;
-
-template<class KeyContainer, class MappedContainer, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<KeyContainer>::value && !flatmap_detail::qualifies_as_allocator<MappedContainer>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value && std::uses_allocator<KeyContainer, Allocator>::value && std::uses_allocator<MappedContainer, Allocator>::value>>
-flat_map(sorted_unique_t, KeyContainer, MappedContainer, Allocator)
-    -> flat_map<typename KeyContainer::value_type,
-                typename MappedContainer::value_type,
-                std::less<typename KeyContainer::value_type>,
-                KeyContainer, MappedContainer>;
-
-template<class InputIterator, class Compare = std::less<flatmap_detail::iter_key_type<InputIterator>>,
+template<class InputIterator,
+         class Key = flatmap_detail::iter_key_type<InputIterator>,
+         class T = flatmap_detail::iter_mapped_type<InputIterator>,
+         class Compare = std::less<Key>,
          class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && !flatmap_detail::qualifies_as_allocator<Compare>::value>>
 flat_map(InputIterator, InputIterator, Compare = Compare())
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>, Compare>;
-
-template<class InputIterator, class Compare, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && !flatmap_detail::qualifies_as_allocator<Compare>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(InputIterator, InputIterator, Compare, Allocator)
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>, Compare>;
-
-template<class InputIterator, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(InputIterator, InputIterator, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>>;
+    -> flat_map<Key, T, Compare>;
 
-template<class InputIterator, class Compare = std::less<flatmap_detail::iter_key_type<InputIterator>>,
+template<class InputIterator,
+         class Key = flatmap_detail::iter_key_type<InputIterator>,
+         class T = flatmap_detail::iter_mapped_type<InputIterator>,
+         class Compare = std::less<Key>,
          class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && !flatmap_detail::qualifies_as_allocator<Compare>::value>>
 flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>, Compare>;
-
-template<class InputIterator, class Compare, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && !flatmap_detail::qualifies_as_allocator<Compare>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(sorted_unique_t, InputIterator, InputIterator, Compare, Allocator)
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>, Compare>;
-
-template<class InputIterator, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_input_iterator<InputIterator>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(sorted_unique_t, InputIterator, InputIterator, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<flatmap_detail::iter_key_type<InputIterator>, flatmap_detail::iter_mapped_type<InputIterator>>;
-
-template<class Key, class T, class Compare = std::less<Key>,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Compare>::value>>
-flat_map(std::initializer_list<std::pair<const Key, T>>, Compare = Compare())
-    -> flat_map<Key, T, Compare>;
-
-template<class Key, class T, class Compare, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Compare>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(std::initializer_list<std::pair<const Key, T>>, Compare, Allocator)
-    -> flat_map<Key, T, Compare>;
-
-template<class Key, class T, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(std::initializer_list<std::pair<const Key, T>>, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<Key, T>;
-
-template<class Key, class T, class Compare = std::less<Key>,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Compare>::value>>
-flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Compare = Compare())
     -> flat_map<Key, T, Compare>;
 
-template<class Key, class T, class Compare, class Allocator,
-         class = std::enable_if_t<!flatmap_detail::qualifies_as_allocator<Compare>::value && flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Compare, Allocator)
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
+template<std::ranges::input_range R,
+         class Key = flatmap_detail::iter_key_type<std::ranges::iterator_t<R>>,
+         class T = flatmap_detail::iter_mapped_type<std::ranges::iterator_t<R>>,
+         class Compare = std::less<Key>>
+flat_map(std::from_range_t, R&&, Compare = Compare())
     -> flat_map<Key, T, Compare>;
+#endif // __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
 
-template<class Key, class T, class Allocator,
-         class = std::enable_if_t<flatmap_detail::qualifies_as_allocator<Allocator>::value>>
-flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Allocator, int=0/*to please MSVC*/)
-    -> flat_map<Key, T>;
-
-#endif
+#endif // __cpp_deduction_guides
 
 } // namespace sg14
diff --git a/test/flat_map_test.cpp b/test/flat_map_test.cpp
index 47d1ac3..3d33761 100644
--- a/test/flat_map_test.cpp
+++ b/test/flat_map_test.cpp
@@ -15,6 +15,10 @@
 #include <sg14/inplace_vector.h>
 #endif
 
+#if __cplusplus >= 202002L
+#include <ranges>
+#endif
+
 template<class T> struct flat_mapt : testing::Test {};
 
 using flat_mapt_types = testing::Types<
@@ -174,6 +178,23 @@ TEST(flat_map, SortedUniqueConstruction)
 #endif
 }
 
+TEST(flat_map, MoveOnly)
+{
+    using T = std::unique_ptr<int>;
+    sg14::flat_map<int, T> fm;
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L && __cpp_lib_ranges_as_rvalue >= 202207L
+    std::vector<std::pair<int, T>> pairs;
+    fm = sg14::flat_map<int, T>(std::from_range, pairs | std::views::as_rvalue);
+    fm = sg14::flat_map<int, T>(std::from_range, pairs | std::views::as_rvalue, std::less<int>());
+#endif
+    std::vector<int> keys;
+    std::vector<T> values;
+    fm.replace(keys, std::move(values));
+    fm.replace(std::move(keys), std::move(values));
+    fm.replace(sg14::sorted_unique, keys, std::move(values));
+    fm.replace(sg14::sorted_unique, std::move(keys), std::move(values));
+}
+
 TEST(flat_map, TryEmplace)
 {
     sg14::flat_map<int, InstrumentedWidget> fm;
@@ -293,128 +314,31 @@ TEST(flat_map, DeductionGuides)
 {
     using sg14::flat_map;
 #if defined(__cpp_deduction_guides)
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
     if (true) {
-        // flat_map(Container)
-        std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(v);
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-        flat_map fm2 = flat_map(std::deque<std::pair<std::string, int>>());
-        static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int>>);
-        std::list<std::pair<const int* const, const int*>> lst;
-        flat_map fm3(lst);
-        static_assert(std::is_same_v<decltype(fm3), flat_map<const int*, const int*>>);
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<std::pair<std::pmr::string, int>> pv;
-        flat_map fm4(pv);
-        static_assert(std::is_same_v<decltype(fm4), flat_map<std::pmr::string, int>>);
-#endif
-        std::initializer_list<std::pair<int, std::string>> il = {{1,"c"}, {5,"b"}, {3,"a"}};
-        flat_map fm5(il);
-        static_assert(std::is_same_v<decltype(fm5), flat_map<int, std::string>>);
-        EXPECT_EQ(fm5.size(), 3);
-        EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}));
-    }
-    if (true) {
-        // flat_map(KeyContainer, MappedContainer)
-        std::vector<int> vi {2,1};
-        std::vector<std::string> vs {"a","b"};
-        flat_map fm1(vi, vs);
-        static_assert(std::is_same_v<decltype(fm1), flat_map<int, std::string>>);
-        EXPECT_EQ(fm1, (flat_map<int, std::string>(sg14::sorted_unique, {{1,"b"}, {2,"a"}})));
-        flat_map fm2(std::move(vs), std::move(vi));
-        static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int>>);
-        EXPECT_EQ(fm2, (flat_map<std::string, int>(sg14::sorted_unique, {{"a",2}, {"b",1}})));
-    }
-    if (true) {
-        // flat_map(Container, Allocator)
-        std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(v, std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<std::pair<std::pmr::string, int>> pv;
-        // TODO: neither of these lines compiles, and it's unclear what is INTENDED to happen
-        // flat_map fm2(pv, std::allocator<int>());
-        // flat_map fm2(pv, std::pmr::polymorphic_allocator<int>());
-#endif
-    }
-    if (true) {
-        // flat_map(KeyContainer, MappedContainer, Allocator)
-        std::vector<int> vi {2,1};
-        std::vector<std::string> vs {"a","b"};
-        flat_map fm1(vi, vs, std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<int, std::string>>);
-        EXPECT_EQ(fm1, (decltype(fm1)(sg14::sorted_unique, {{1,"b"}, {2,"a"}})));
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<int> pvi {2,1};
-        std::pmr::vector<std::pmr::string> pvs {"a","b"};
-        flat_map fm2(pvi, pvs, std::pmr::polymorphic_allocator<char>());
-        static_assert(std::is_same_v<decltype(fm2), flat_map<int, std::pmr::string, std::less<int>, std::pmr::vector<int>, std::pmr::vector<std::pmr::string>>>);
-        EXPECT_EQ(fm2, (decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}})));
-#endif
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, Container)
+        // flat_map(std::from_range_t, R&&)
         std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(sg14::sorted_unique, v);
+        flat_map fm1(std::from_range, v);
         static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-        flat_map fm2 = flat_map(sg14::sorted_unique, std::deque<std::pair<std::string, int>>());
+        flat_map fm2 = flat_map(std::from_range, std::deque<std::pair<std::string, int>>());
         static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int>>);
         std::list<std::pair<const int* const, const int*>> lst;
-        flat_map fm3(sg14::sorted_unique, lst);
+        flat_map fm3(std::from_range, lst);
         static_assert(std::is_same_v<decltype(fm3), flat_map<const int*, const int*>>);
 #if __cpp_lib_memory_resource >= 201603
         std::pmr::vector<std::pair<std::pmr::string, int>> pv;
-        flat_map fm4(sg14::sorted_unique, pv);
+        flat_map fm4(std::from_range, pv);
         static_assert(std::is_same_v<decltype(fm4), flat_map<std::pmr::string, int>>);
 #endif
-        std::initializer_list<std::pair<int, std::string>> il = {{1,"c"}, {3,"b"}, {5,"a"}};
-        flat_map fm5(sg14::sorted_unique, il);
-        static_assert(std::is_same_v<decltype(fm5), flat_map<int, std::string>>);
-        EXPECT_EQ(fm5, (decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"b"}, {5,"a"}})));
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, KeyContainer, MappedContainer)
-        std::vector<int> vi {1,2};
-        std::vector<std::string> vs {"a","b"};
-        flat_map fm1(sg14::sorted_unique, vi, vs);
-        static_assert(std::is_same_v<decltype(fm1), flat_map<int, std::string>>);
-        EXPECT_EQ(fm1, decltype(fm1)(sg14::sorted_unique, {{1,"a"}, {2,"b"}}));
-        flat_map fm2(sg14::sorted_unique, std::move(vs), std::move(vi));
-        static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int>>);
-        EXPECT_EQ(fm2, decltype(fm2)(sg14::sorted_unique, {{"a",1}, {"b",2}}));
     }
+#endif // __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
     if (true) {
-        // flat_map(sorted_unique_t, Container, Allocator)
-        std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(sg14::sorted_unique, v, std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<std::pair<std::pmr::string, int>> pv;
-        // TODO: neither of these lines compiles, and it's unclear what is INTENDED to happen
-        // flat_map fm2(sg14::sorted_unique, pv, std::allocator<int>());
-        // flat_map fm2(sg14::sorted_unique, pv, std::pmr::polymorphic_allocator<int>());
-#endif
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, KeyContainer, MappedContainer, Allocator)
-        std::vector<int> vi {2,1};
-        std::vector<std::string> vs {"a","b"};
-        flat_map fm1(sg14::sorted_unique, vs, vi, std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-        EXPECT_EQ(fm1, decltype(fm1)(sg14::sorted_unique, {{"a",2}, {"b",1}}));
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<int> pvi {1, 2};
-        std::pmr::vector<std::pmr::string> pvs {"b","a"};
-        flat_map fm2(sg14::sorted_unique, pvi, pvs, std::pmr::polymorphic_allocator<char>());
-        static_assert(std::is_same_v<decltype(fm2), flat_map<int, std::pmr::string, std::less<int>, std::pmr::vector<int>, std::pmr::vector<std::pmr::string>>>);
-        EXPECT_EQ(fm2, decltype(fm2)(sg14::sorted_unique, {{1,"b"}, {2,"a"}}));
-#endif
-    }
-    if (true) {
-        // flat_map(InputIterator, InputIterator, Compare = Compare())
+        // flat_map(InputIterator, InputIterator)
         std::vector<std::pair<std::string, int>> v;
         flat_map fm1(v.begin(), v.end());
         static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
+        flat_map fm2(sg14::sorted_unique, v.begin(), v.end());
+        static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int>>);
         std::list<std::pair<const int* const, const int*>> lst;
         flat_map fm3(lst.begin(), lst.end());
         static_assert(std::is_same_v<decltype(fm3), flat_map<const int*, const int*>>);
@@ -429,18 +353,12 @@ TEST(flat_map, DeductionGuides)
         EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}));
     }
     if (true) {
-        // flat_map(InputIterator, InputIterator, Compare = Compare())
+        // flat_map(InputIterator, InputIterator, Compare)
         std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(v.begin(), v.end(), std::less<std::string>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-        int x = 3;
-        std::pair<int, int> arr[] = {{1,2}, {2,3}, {3,4}, {4,5}};
-        flat_map fm2(arr, arr + 4, [&x](int a, int b){ return (a % x) < (b % x); });
-        EXPECT_FALSE(fm2.key_comp()(2, 4));
-        x = 10;
-        EXPECT_TRUE(fm2.key_comp()(2, 4));
-        x = 3;
-        EXPECT_EQ(fm2.begin()[0].first, 3);
+        flat_map fm1(v.begin(), v.end(), std::less<>());
+        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int, std::less<>>>);
+        flat_map fm2(sg14::sorted_unique, v.begin(), v.end(), std::less<>());
+        static_assert(std::is_same_v<decltype(fm2), flat_map<std::string, int, std::less<>>>);
         std::list<std::pair<const int* const, const int*>> lst;
         flat_map fm3(lst.begin(), lst.end(), std::greater<>());
         static_assert(std::is_same_v<decltype(fm3), flat_map<const int*, const int*, std::greater<>>>);
@@ -450,77 +368,16 @@ TEST(flat_map, DeductionGuides)
         static_assert(std::is_same_v<decltype(fm4), flat_map<std::pmr::string, int, std::greater<std::pmr::string>>>);
 #endif
         std::initializer_list<std::pair<int, std::string>> il = {{1,"c"}, {5,"b"}, {3,"a"}};
-        flat_map fm5(il.begin(), il.end(), std::less<int>());
-        static_assert(std::is_same_v<decltype(fm5), flat_map<int, std::string>>);
+        flat_map fm5(il.begin(), il.end(), std::less<>());
+        static_assert(std::is_same_v<decltype(fm5), flat_map<int, std::string, std::less<>>>);
         EXPECT_EQ(fm5, decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}));
 
+        std::pair<int, int> arr[] = {{1,2}, {3,4}, {2,3}, {4,5}};
         flat_map fm6(arr, arr + 4, free_function_less);
         static_assert(std::is_same_v<decltype(fm6), flat_map<int, int, bool(*)(const int&, const int&)>>);
         EXPECT_EQ(fm6.key_comp(), free_function_less);
         EXPECT_EQ(fm6, decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less));
     }
-    if (true) {
-        // flat_map(InputIterator, InputIterator, Compare, Allocator)
-        std::vector<std::pair<std::string, int>> v;
-        flat_map fm1(v.begin(), v.end(), std::less<std::string>(), std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm1), flat_map<std::string, int>>);
-        int x = 3;
-        std::pair<int, int> arr[] = {{1,2}, {2,3}, {3,4}, {4,5}};
-        flat_map fm2(arr, arr + 4, [&x](int a, int b){ return (a % x) < (b % x); }, std::allocator<int>());
-        EXPECT_FALSE(fm2.key_comp()(2, 4));
-        x = 10;
-        EXPECT_TRUE(fm2.key_comp()(2, 4));
-        x = 3;
-        EXPECT_EQ(fm2.begin()[0].first, 3);
-        std::list<std::pair<const int* const, const int*>> lst;
-        flat_map fm3(lst.begin(), lst.end(), std::greater<>(), std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm3), flat_map<const int*, const int*, std::greater<>>>);
-#if __cpp_lib_memory_resource >= 201603
-        std::pmr::vector<std::pair<std::pmr::string, int>> pv;
-        flat_map fm4(pv.begin(), pv.end(), std::greater<>(), std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm4), flat_map<std::pmr::string, int, std::greater<>>>);
-        EXPECT_TRUE(!flatmap_is_ctadable_from(0, pv.begin(), pv.end(), std::greater<int>(), std::pmr::polymorphic_allocator<int>()));
-#endif
-        std::initializer_list<std::pair<int, std::string>> il = {{1,"c"}, {5,"b"}, {3,"a"}};
-        flat_map fm5(il.begin(), il.end(), std::less<int>(), std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm5), flat_map<int, std::string>>);
-        EXPECT_TRUE(( fm5 == decltype(fm5)(sg14::sorted_unique, {{1,"c"}, {3,"a"}, {5,"b"}}) ));
-
-        flat_map fm6(arr, arr + 4, free_function_less, std::allocator<int>());
-        static_assert(std::is_same_v<decltype(fm6), flat_map<int, int, bool(*)(const int&, const int&)>>);
-        EXPECT_TRUE(fm6.key_comp() == free_function_less);
-        EXPECT_TRUE(( fm6 == decltype(fm6)(sg14::sorted_unique, {{1,2}, {2,3}, {3,4}, {4,5}}, free_function_less) ));
-    }
-    if (true) {
-        // flat_map(InputIterator, InputIterator, Allocator)
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, InputIterator, InputIterator, Compare, Allocator)
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, InputIterator, InputIterator, Allocator)
-    }
-    if (true) {
-        // flat_map(std::initializer_list<std::pair<const Key, T>>, Compare = Compare())
-    }
-    if (true) {
-        // flat_map(std::initializer_list<std::pair<const Key, T>>, Compare, Allocator)
-    }
-    if (true) {
-        // flat_map(std::initializer_list<std::pair<const Key, T>>, Allocator)
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Compare = Compare())
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Compare, Allocator)
-    }
-    if (true) {
-        // flat_map(sorted_unique_t, std::initializer_list<std::pair<const Key, T>>, Allocator)
-    }
 #endif // defined(__cpp_deduction_guides)
 }
 
@@ -554,16 +411,20 @@ TYPED_TEST(flat_mapt, Construction)
         EXPECT_TRUE(fs[5] == Str("b"));
     }
     for (auto&& fs : {
+#if __cpp_lib_ranges >= 201911L && __cpp_lib_ranges_to_container >= 202202L
+        FS(std::from_range, pairs),
+        FS(std::from_range, pairs, Compare()),
+#endif
         FS({{1, "a"}, {3, "c"}, {5, "b"}}),
         FS(pairs.begin(), pairs.end()),
         FS(pairs.rbegin(), pairs.rend()),
-        FS(pairs, Compare()),
         FS({{1, "a"}, {3, "c"}, {5, "b"}}, Compare()),
         FS(pairs.begin(), pairs.end(), Compare()),
         FS(pairs.rbegin(), pairs.rend(), Compare()),
     }) {
         EXPECT_TRUE(std::is_sorted(fs.keys().begin(), fs.keys().end(), fs.key_comp()));
         EXPECT_TRUE(std::is_sorted(fs.begin(), fs.end(), fs.value_comp()));
+        EXPECT_EQ(fs.size(), 3u);
         EXPECT_TRUE(fs.find(0) == fs.end());
         EXPECT_TRUE(fs.find(1) != fs.end());
         EXPECT_TRUE(fs.find(2) == fs.end());
@@ -577,10 +438,8 @@ TYPED_TEST(flat_mapt, Construction)
     }
     if (std::is_sorted(keys.begin(), keys.end(), Compare())) {
         for (auto&& fs : {
-            FS(sg14::sorted_unique, pairs),
             FS(sg14::sorted_unique, pairs.begin(), pairs.end()),
             FS(sg14::sorted_unique, {{1, "a"}, {3, "c"}, {5, "b"}}),
-            FS(sg14::sorted_unique, pairs, Compare()),
             FS(sg14::sorted_unique, pairs.begin(), pairs.end(), Compare()),
             FS(sg14::sorted_unique, {{1, "a"}, {3, "c"}, {5, "b"}}, Compare()),
         }) {
diff --git a/test/flat_set_test.cpp b/test/flat_set_test.cpp
index 3213381..d003c0e 100644
--- a/test/flat_set_test.cpp
+++ b/test/flat_set_test.cpp
@@ -9,9 +9,6 @@
 #if __has_include(<memory_resource>)
 #include <memory_resource>
 #endif
-#if __has_include(<ranges>)
-#include <ranges>
-#endif
 #include <string>
 #include <vector>
 
@@ -19,6 +16,10 @@
 #include <sg14/inplace_vector.h>
 #endif
 
+#if __cplusplus >= 202002L
+#include <ranges>
+#endif
+
 template<class T> struct flat_sett : testing::Test {};
 
 using flat_sett_types = testing::Types<