added interoperability with C++20 ranges

.github/workflows/ci.yml

@@ -383,6 +383,7 @@ jobs:
           B2_SANITIZE: ${{matrix.sanitize}}
           B2_STDLIB: ${{matrix.stdlib}}
           B2_VARIANT: ${{matrix.variant}}
+          B2_JOBS: ${{ matrix.sys == 'MINGW32' && '2' || '' }}
         run: ci/github/install.sh
 
       - name: Run tests

doc/modules/ROOT/pages/changes.adoc

@@ -6,6 +6,14 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.92.0
+
+* Added interoperability with pass:[C++20] ranges to all the containers in the library:
+`insert_range` (plus `insert_range_(or|and)_[c]visit` for concurrent containers),
+`std::from_range` construction and associated CTAD deduction guides.
+The `boost::unordered::from_range` construction tag is provided
+as an alternative to pass:[C++23] `std::from_range` or when this is not available.
+
 == Release 1.91.0
 
 * Fixed the returned value of range insertion in concurrent containers

doc/modules/ROOT/pages/reference/header_concurrent_flat_map.adoc

@@ -19,6 +19,10 @@ namespace unordered {
            class Allocator = std::allocator<std::pair<const Key, T>>>
   class xref:reference/concurrent_flat_map.adoc#concurrent_flat_map[concurrent_flat_map];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class T, class Hash, class Pred, class Alloc>
     bool xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_operator[operator++==++](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
@@ -39,7 +43,7 @@ namespace unordered {
     typename concurrent_flat_map<K, T, H, P, A>::size_type
       xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_erase_if[erase_if](concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class T,

doc/modules/ROOT/pages/reference/header_concurrent_flat_set.adoc

@@ -18,6 +18,10 @@ namespace unordered {
            class Allocator = std::allocator<Key>>
   class xref:reference/concurrent_flat_set.adoc#concurrent_flat_set[concurrent_flat_set];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class Hash, class Pred, class Alloc>
     bool xref:reference/concurrent_flat_set.adoc#concurrent_flat_set_operator[operator++==++](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
@@ -38,7 +42,7 @@ namespace unordered {
     typename concurrent_flat_set<K, H, P, A>::size_type
       xref:reference/concurrent_flat_set.adoc#concurrent_flat_set_erase_if[erase_if](concurrent_flat_set<K, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class Hash = boost::hash<Key>,

doc/modules/ROOT/pages/reference/header_concurrent_node_map.adoc

@@ -19,6 +19,10 @@ namespace unordered {
            class Allocator = std::allocator<std::pair<const Key, T>>>
   class xref:reference/concurrent_node_map.adoc#concurrent_node_map[concurrent_node_map];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class T, class Hash, class Pred, class Alloc>
     bool xref:reference/concurrent_node_map.adoc#concurrent_node_map_operator[operator++==++](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
@@ -39,7 +43,7 @@ namespace unordered {
     typename concurrent_node_map<K, T, H, P, A>::size_type
       xref:reference/concurrent_node_map.adoc#concurrent_node_map_erase_if[erase_if](concurrent_node_map<K, T, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class T,

doc/modules/ROOT/pages/reference/header_concurrent_node_set.adoc

@@ -18,6 +18,10 @@ namespace unordered {
            class Allocator = std::allocator<Key>>
   class xref:reference/concurrent_node_set.adoc#concurrent_node_set[concurrent_node_set];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class Hash, class Pred, class Alloc>
     bool xref:reference/concurrent_node_set.adoc#concurrent_node_set_operator[operator++==++](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
@@ -38,7 +42,7 @@ namespace unordered {
     typename concurrent_node_set<K, H, P, A>::size_type
       xref:reference/concurrent_node_set.adoc#concurrent_node_set_erase_if[erase_if](concurrent_node_set<K, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class Hash = boost::hash<Key>,

doc/modules/ROOT/pages/reference/header_unordered_flat_map.adoc

@@ -19,6 +19,10 @@ namespace unordered {
            class Allocator = std::allocator<std::pair<const Key, T>>>
   class xref:reference/unordered_flat_map.adoc#unordered_flat_map[unordered_flat_map];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class T, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_flat_map.adoc#unordered_flat_map_operator_2[operator++==++](const unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
@@ -39,7 +43,7 @@ namespace unordered {
     typename unordered_flat_map<K, T, H, P, A>::size_type
       xref:reference/unordered_flat_map.adoc#unordered_flat_map_erase_if[erase_if](unordered_flat_map<K, T, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class T,

doc/modules/ROOT/pages/reference/header_unordered_flat_set.adoc

@@ -18,6 +18,10 @@ namespace unordered {
            class Allocator = std::allocator<Key>>
   class xref:reference/unordered_flat_set.adoc#unordered_flat_set[unordered_flat_set];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_flat_set.adoc#unordered_flat_set_operator[operator++==++](const unordered_flat_set<Key, Hash, Pred, Alloc>& x,
@@ -38,7 +42,7 @@ namespace unordered {
     typename unordered_flat_set<K, H, P, A>::size_type
       xref:reference/unordered_flat_set.adoc#unordered_flat_set_erase_if[erase_if](unordered_flat_set<K, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class Hash = boost::hash<Key>,

doc/modules/ROOT/pages/reference/header_unordered_map.adoc

@@ -20,6 +20,10 @@ namespace unordered {
            class Allocator = std::allocator<std::pair<const Key, T>>>
   class xref:reference/unordered_map.adoc#unordered_map[unordered_map];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class T, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_map.adoc#unordered_map_operator_2[operator++==++](const unordered_map<Key, T, Hash, Pred, Alloc>& x,
@@ -67,7 +71,7 @@ namespace unordered {
     typename unordered_multimap<K, T, H, P, A>::size_type
       xref:reference/unordered_multimap.adoc#unordered_multimap_erase_if[erase_if](unordered_multimap<K, T, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class T,

doc/modules/ROOT/pages/reference/header_unordered_node_map.adoc

@@ -19,6 +19,10 @@ namespace unordered {
            class Allocator = std::allocator<std::pair<const Key, T>>>
   class xref:reference/unordered_node_map.adoc#unordered_node_map[unordered_node_map];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class T, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_node_map.adoc#unordered_node_map_operator_2[operator++==++](const unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
@@ -39,7 +43,7 @@ namespace unordered {
     typename unordered_node_map<K, T, H, P, A>::size_type
       xref:reference/unordered_node_map.adoc#unordered_node_map_erase_if[erase_if](unordered_node_map<K, T, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class T,

doc/modules/ROOT/pages/reference/header_unordered_node_set.adoc

@@ -18,6 +18,10 @@ namespace unordered {
            class Allocator = std::allocator<Key>>
   class xref:reference/unordered_node_set.adoc#unordered_node_set[unordered_node_set];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_node_set.adoc#unordered_node_set_operator[operator++==++](const unordered_node_set<Key, Hash, Pred, Alloc>& x,
@@ -38,7 +42,7 @@ namespace unordered {
     typename unordered_node_set<K, H, P, A>::size_type
       xref:reference/unordered_node_set.adoc#unordered_node_set_erase_if[erase_if](unordered_node_set<K, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class Hash = boost::hash<Key>,

doc/modules/ROOT/pages/reference/header_unordered_set.adoc

@@ -19,6 +19,10 @@ namespace unordered {
            class Allocator = std::allocator<Key>>
   class xref:reference/unordered_set.adoc#unordered_set[unordered_set];
 
+  // Tag for construction from ranges (pass:[C++20] and up)
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
+
   // Equality Comparisons
   template<class Key, class Hash, class Pred, class Alloc>
     bool xref:reference/unordered_set.adoc#unordered_set_operator[operator++==++](const unordered_set<Key, Hash, Pred, Alloc>& x,
@@ -65,7 +69,7 @@ namespace unordered {
     typename unordered_multiset<K, H, P, A>::size_type
       xref:reference/unordered_multiset.adoc#unordered_multiset_erase_if[erase_if](unordered_multiset<K, H, P, A>& c, Predicate pred);
 
-  // Pmr aliases (C++17 and up)
+  // Pmr aliases (pass:[C++17] and up)
   namespace pmr {
     template<class Key,
              class Hash = boost::hash<Key>,