added header synopses to the reference (#303)

* added header synopses to the reference

* disabled font color override for in-link code portions

* relinked bundle

doc/modules/ROOT/nav.adoc

@@ -10,20 +10,42 @@
 * xref:benchmarks.adoc[]
 * xref:rationale.adoc[]
 * xref:ref.adoc[]
-** xref:reference/unordered_map.adoc[unordered_map]
-** xref:reference/unordered_multimap.adoc[unordered_multimap]
-** xref:reference/unordered_set.adoc[unordered_set]
-** xref:reference/unordered_multiset.adoc[unordered_multiset]
-** xref:reference/hash_traits.adoc[hash_traits]
+** xref:reference/header_unordered_map_fwd.adoc[`<boost/unordered/unordered_map_fwd.hpp>`]
+** xref:reference/header_unordered_map_top.adoc[`<boost/unordered_map.hpp>`]
+** xref:reference/header_unordered_map.adoc[`<boost/unordered/unordered_map.hpp>`]
+** xref:reference/unordered_map.adoc[`unordered_map`]
+** xref:reference/unordered_multimap.adoc[`unordered_multimap`]
+** xref:reference/header_unordered_set_fwd.adoc[`<boost/unordered/unordered_set_fwd.hpp>`]
+** xref:reference/header_unordered_set_top.adoc[`<boost/unordered_set.hpp>`]
+** xref:reference/header_unordered_set.adoc[`<boost/unordered/unordered_set.hpp>`]
+** xref:reference/unordered_set.adoc[`unordered_set`]
+** xref:reference/unordered_multiset.adoc[`unordered_multiset`]
+** xref:reference/hash_traits.adoc[Hash Traits]
 ** xref:reference/stats.adoc[Statistics]
-** xref:reference/unordered_flat_map.adoc[unordered_flat_map]
-** xref:reference/unordered_flat_set.adoc[unordered_flat_set]
-** xref:reference/unordered_node_map.adoc[unordered_node_map]
-** xref:reference/unordered_node_set.adoc[unordered_node_set]
-** xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
-** xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
-** xref:reference/concurrent_node_map.adoc[concurrent_node_map]
-** xref:reference/concurrent_node_set.adoc[concurrent_node_set]
+** xref:reference/header_unordered_flat_map_fwd.adoc[`<boost/unordered/unordered_flat_map_fwd.hpp>`]
+** xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`]
+** xref:reference/unordered_flat_map.adoc[`unordered_flat_map`]
+** xref:reference/header_unordered_flat_set_fwd.adoc[`<boost/unordered/unordered_flat_set_fwd.hpp>`]
+** xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>`]
+** xref:reference/unordered_flat_set.adoc[`unordered_flat_set`]
+** xref:reference/header_unordered_node_map_fwd.adoc[`<boost/unordered/unordered_node_map_fwd.hpp>`]
+** xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>`]
+** xref:reference/unordered_node_map.adoc[`unordered_node_map`]
+** xref:reference/header_unordered_node_set_fwd.adoc[`<boost/unordered/unordered_node_set_fwd.hpp>`]
+** xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`]
+** xref:reference/unordered_node_set.adoc[`unordered_node_set`]
+** xref:reference/header_concurrent_flat_map_fwd.adoc[`<boost/unordered/concurrent_flat_map_fwd.hpp>`]
+** xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
+** xref:reference/concurrent_flat_map.adoc[`concurrent_flat_map`]
+** xref:reference/header_concurrent_flat_set_fwd.adoc[`<boost/unordered/concurrent_flat_set_fwd.hpp>`]
+** xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
+** xref:reference/concurrent_flat_set.adoc[`concurrent_flat_set`]
+** xref:reference/header_concurrent_node_map_fwd.adoc[`<boost/unordered/concurrent_node_map_fwd.hpp>`]
+** xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
+** xref:reference/concurrent_node_map.adoc[`concurrent_node_map`]
+** xref:reference/header_concurrent_node_set_fwd.adoc[`<boost/unordered/concurrent_node_set_fwd.hpp>`]
+** xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
+** xref:reference/concurrent_node_set.adoc[`concurrent_node_set`]
 * xref:changes.adoc[]
 * xref:bibliography.adoc[]
 * xref:copyright.adoc[]

doc/modules/ROOT/pages/changes.adoc

@@ -6,6 +6,10 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.88.0
+
+* Migrated the documentation to a multipage format using Antora.
+
 == Release 1.87.0 - Major update
 
 * Added concurrent, node-based containers `boost::concurrent_node_map` and `boost::concurrent_node_set`.

doc/modules/ROOT/pages/copyright.adoc

@@ -9,9 +9,9 @@ Copyright (C) 2003, 2004 Jeremy B. Maitin-Shepard
 
 Copyright (C) 2005-2008 Daniel James
 
-Copyright (C) 2022-2023 Christian Mazakas
+Copyright (C) 2022-2025 Christian Mazakas
 
-Copyright (C) 2022-2024 Joaquín M López Muñoz
+Copyright (C) 2022-2025 Joaquín M López Muñoz
 
 Copyright (C) 2022-2023 Peter Dimov
 

doc/modules/ROOT/pages/ref.adoc

@@ -1,17 +1,39 @@
 [#reference]
 = Reference
 
-* xref:reference/unordered_map.adoc[unordered_map]
-* xref:reference/unordered_multimap.adoc[unordered_multimap]
-* xref:reference/unordered_set.adoc[unordered_set]
-* xref:reference/unordered_multiset.adoc[unordered_multiset]
-* xref:reference/hash_traits.adoc[hash_traits]
+* xref:reference/header_unordered_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_map_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_map_top.adoc[+++<code style="color: inherit;">+++<boost/unordered_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_map+++</code>+++]
+* xref:reference/unordered_multimap.adoc[Class Template +++<code style="color: inherit;">+++unordered_multimap+++</code>+++]
+* xref:reference/header_unordered_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_set_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_set_top.adoc[+++<code style="color: inherit;">+++<boost/unordered_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_set+++</code>+++]
+* xref:reference/unordered_multiset.adoc[Class Template +++<code style="color: inherit;">+++unordered_multiset+++</code>+++]
+* xref:reference/hash_traits.adoc[Hash Traits]
 * xref:reference/stats.adoc[Statistics]
-* xref:reference/unordered_flat_map.adoc[unordered_flat_map]
-* xref:reference/unordered_flat_set.adoc[unordered_flat_set]
-* xref:reference/unordered_node_map.adoc[unordered_node_map]
-* xref:reference/unordered_node_set.adoc[unordered_node_set]
-* xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
-* xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
-* xref:reference/concurrent_node_map.adoc[concurrent_node_map]
-* xref:reference/concurrent_node_set.adoc[concurrent_node_set]
+* xref:reference/header_unordered_flat_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_map_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_flat_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_flat_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_flat_map+++</code>+++]
+* xref:reference/header_unordered_flat_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_set_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_flat_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_flat_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_flat_set+++</code>+++]
+* xref:reference/header_unordered_node_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_map_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_node_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_node_map.adoc[Class Template +++<code style="color: inherit;">+++unordered_node_map+++</code>+++]
+* xref:reference/header_unordered_node_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_set_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_unordered_node_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_node_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/unordered_node_set.adoc[Class Template +++<code style="color: inherit;">+++unordered_node_set+++</code>+++]
+* xref:reference/header_concurrent_flat_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_map_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_concurrent_flat_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/concurrent_flat_map.adoc[Class Template +++<code style="color: inherit;">+++concurrent_flat_map+++</code>+++]
+* xref:reference/header_concurrent_flat_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_set_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_concurrent_flat_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/concurrent_flat_set.adoc[Class Template +++<code style="color: inherit;">+++concurrent_flat_set+++</code>+++]
+* xref:reference/header_concurrent_node_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_map_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_concurrent_node_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_map.hpp>+++</code>+++ Synopsis]
+* xref:reference/concurrent_node_map.adoc[Class Template +++<code style="color: inherit;">+++concurrent_node_map+++</code>+++]
+* xref:reference/header_concurrent_node_set_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_set_fwd.hpp>+++</code>+++ Synopsis]
+* xref:reference/header_concurrent_node_set.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_node_set.hpp>+++</code>+++ Synopsis]
+* xref:reference/concurrent_node_set.adoc[Class Template +++<code style="color: inherit;">+++concurrent_node_set+++</code>+++]

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

@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_map` is similar to that o
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_flat_map.hpp>
+// #include xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -320,37 +322,8 @@ namespace boost {
                         Hash, Allocator)
       -> concurrent_flat_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_map_operator[operator==](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_map_operator_2[operator!=](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_flat_map_swap_2[swap](concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
-              concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename concurrent_flat_map<K, T, H, P, A>::size_type
-       xref:#concurrent_flat_map_erase_if_2[erase_if](concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using concurrent_flat_map =
-      boost::concurrent_flat_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -22,9 +22,11 @@ The internal data structure of `boost::concurrent_flat_set` is similar to that o
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_flat_set.hpp>
+// #include xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -270,36 +272,8 @@ namespace boost {
     concurrent_flat_set(std::initializer_list<T>, typename xref:#concurrent_flat_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> concurrent_flat_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_set_operator[operator==](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
-
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_flat_set_operator_2[operator!=](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_flat_set_swap_2[swap](concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
-              concurrent_flat_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class H, class P, class A, class Predicate>
-    typename concurrent_flat_set<K, H, P, A>::size_type
-       xref:#concurrent_flat_set_erase_if_2[erase_if](concurrent_flat_set<K, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using concurrent_flat_set =
-      boost::concurrent_flat_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_node_map.hpp>
+// #include xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -338,37 +340,8 @@ namespace boost {
                         Hash, Allocator)
       -> concurrent_node_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_map_operator[operator==](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_map_operator_2[operator!=](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_node_map_swap_2[swap](concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
-              concurrent_node_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename concurrent_node_map<K, T, H, P, A>::size_type
-       xref:#concurrent_node_map_erase_if_2[erase_if](concurrent_node_map<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using concurrent_node_map =
-      boost::concurrent_node_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -22,9 +22,11 @@ node handling functionalities are provided, at the expense of potentially lower
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/concurrent_node_set.hpp>
+// #include xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -287,36 +289,8 @@ namespace boost {
     concurrent_node_set(std::initializer_list<T>, typename xref:#concurrent_node_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> concurrent_node_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_set_operator[operator==](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
-
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#concurrent_node_set_operator_2[operator!=](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#concurrent_node_set_swap_2[swap](concurrent_node_set<Key, Hash, Pred, Alloc>& x,
-              concurrent_node_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class H, class P, class A, class Predicate>
-    typename concurrent_node_set<K, H, P, A>::size_type
-       xref:#concurrent_node_set_erase_if_2[erase_if](concurrent_node_set<K, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using concurrent_node_set =
-      boost::concurrent_node_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -1,14 +1,12 @@
 [#hash_traits]
-== Hash traits
+== Hash Traits
 
 :idprefix: hash_traits_
 
-=== Synopsis
+=== `<boost/unordered/hash_traits.hpp>` Synopsis
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/hash_traits.hpp>
-
 namespace boost {
 namespace unordered {
 

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

@@ -0,0 +1,58 @@
+[#header_concurrent_flat_map]
+== `<boost/unordered/concurrent_flat_map.hpp>` Synopsis
+
+:idprefix: header_concurrent_flat_map_
+
+Defines `xref:reference/concurrent_flat_map.adoc#concurrent_flat_map[boost::concurrent_flat_map]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/concurrent_flat_map.adoc#concurrent_flat_map[concurrent_flat_map];
+
+  // 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,
+                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_operator_2[operator!=](const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
+                    const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_swap_2[swap](concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
+              concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_flat_map =
+      boost::unordered::concurrent_flat_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::concurrent_flat_map;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_concurrent_flat_map_fwd]
+== `<boost/unordered/concurrent_flat_map_fwd.hpp>` Synopsis
+
+:idprefix: header_concurrent_flat_map_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_concurrent_flat_map.adoc[`<boost/unordered/concurrent_flat_map.hpp>`].

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

@@ -0,0 +1,56 @@
+[#header_concurrent_flat_set]
+== `<boost/unordered/concurrent_flat_set.hpp>` Synopsis
+
+:idprefix: header_concurrent_flat_set_
+
+Defines `xref:reference/concurrent_flat_set.adoc#concurrent_flat_set[boost::concurrent_flat_set]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/concurrent_flat_set.adoc#concurrent_flat_set[concurrent_flat_set];
+
+  // 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,
+                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/concurrent_flat_set.adoc#concurrent_flat_set_operator_2[operator!=](const concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
+                    const concurrent_flat_set<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/concurrent_flat_set.adoc#concurrent_flat_set_swap_2[swap](concurrent_flat_set<Key, Hash, Pred, Alloc>& x,
+              concurrent_flat_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_flat_set =
+      boost::unordered::concurrent_flat_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::concurrent_flat_set;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_concurrent_flat_set_fwd]
+== `<boost/unordered/concurrent_flat_set_fwd.hpp>` Synopsis
+
+:idprefix: header_concurrent_flat_set_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_concurrent_flat_set.adoc[`<boost/unordered/concurrent_flat_set.hpp>`].

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

@@ -0,0 +1,58 @@
+[#header_concurrent_node_map]
+== `<boost/unordered/concurrent_node_map.hpp>` Synopsis
+
+:idprefix: header_concurrent_node_map_
+
+Defines `xref:reference/concurrent_node_map.adoc#concurrent_node_map[boost::concurrent_node_map]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/concurrent_node_map.adoc#concurrent_node_map[concurrent_node_map];
+
+  // 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,
+                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/concurrent_node_map.adoc#concurrent_node_map_operator_2[operator!=](const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
+                    const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/concurrent_node_map.adoc#concurrent_node_map_swap_2[swap](concurrent_node_map<Key, T, Hash, Pred, Alloc>& x,
+              concurrent_node_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_node_map =
+      boost::unordered::concurrent_node_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::concurrent_node_map;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_concurrent_node_map_fwd]
+== `<boost/unordered/concurrent_node_map_fwd.hpp>` Synopsis
+
+:idprefix: header_concurrent_node_map_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_concurrent_node_map.adoc[`<boost/unordered/concurrent_node_map.hpp>`].

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

@@ -0,0 +1,56 @@
+[#header_concurrent_node_set]
+== `<boost/unordered/concurrent_node_set.hpp>` Synopsis
+
+:idprefix: header_concurrent_node_set_
+
+Defines `xref:reference/concurrent_node_set.adoc#concurrent_node_set[boost::concurrent_node_set]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/concurrent_node_set.adoc#concurrent_node_set[concurrent_node_set];
+
+  // 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,
+                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/concurrent_node_set.adoc#concurrent_node_set_operator_2[operator!=](const concurrent_node_set<Key, Hash, Pred, Alloc>& x,
+                    const concurrent_node_set<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/concurrent_node_set.adoc#concurrent_node_set_swap_2[swap](concurrent_node_set<Key, Hash, Pred, Alloc>& x,
+              concurrent_node_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using concurrent_node_set =
+      boost::unordered::concurrent_node_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::concurrent_node_set;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_concurrent_node_set_fwd]
+== `<boost/unordered/concurrent_node_set_fwd.hpp>` Synopsis
+
+:idprefix: header_concurrent_node_set_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_concurrent_node_set.adoc[`<boost/unordered/concurrent_node_set.hpp>`].

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

@@ -0,0 +1,58 @@
+[#header_unordered_flat_map]
+== `<boost/unordered/unordered_flat_map.hpp>` Synopsis
+
+:idprefix: header_unordered_flat_map_
+
+Defines `xref:reference/unordered_flat_map.adoc#unordered_flat_map[boost::unordered_flat_map]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/unordered_flat_map.adoc#unordered_flat_map[unordered_flat_map];
+
+  // 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,
+                    const unordered_flat_map<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_flat_map.adoc#unordered_flat_map_operator_3[operator!=](const unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
+                    const unordered_flat_map<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_flat_map.adoc#unordered_flat_map_swap_2[swap](unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
+              unordered_flat_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_flat_map =
+      boost::unordered::unordered_flat_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_flat_map;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_flat_map_fwd]
+== `<boost/unordered/unordered_flat_map_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_flat_map_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`].

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

@@ -0,0 +1,56 @@
+[#header_unordered_flat_set]
+== `<boost/unordered/unordered_flat_set.hpp>` Synopsis
+
+:idprefix: header_unordered_flat_set_
+
+Defines `xref:reference/unordered_flat_set.adoc#unordered_flat_set[boost::unordered_flat_set]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/unordered_flat_set.adoc#unordered_flat_set[unordered_flat_set];
+
+  // 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,
+                    const unordered_flat_set<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_flat_set.adoc#unordered_flat_set_operator_2[operator!=](const unordered_flat_set<Key, Hash, Pred, Alloc>& x,
+                    const unordered_flat_set<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_flat_set.adoc#unordered_flat_set_swap_2[swap](unordered_flat_set<Key, Hash, Pred, Alloc>& x,
+              unordered_flat_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_flat_set =
+      boost::unordered::unordered_flat_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_flat_set;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_flat_set_fwd]
+== `<boost/unordered/unordered_flat_set_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_flat_set_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>`].

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

@@ -0,0 +1,95 @@
+[#header_unordered_map]
+== `<boost/unordered/unordered_map.hpp>` Synopsis
+
+:idprefix: header_unordered_map_
+
+Defines `xref:reference/unordered_map.adoc#unordered_map[boost::unordered_map]`,
+`xref:reference/unordered_multimap.adoc#unordered_multimap[boost::unordered_multimap]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/unordered_map.adoc#unordered_map[unordered_map];
+
+  // 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,
+                    const unordered_map<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_map.adoc#unordered_map_operator_3[operator!=](const unordered_map<Key, T, Hash, Pred, Alloc>& x,
+                    const unordered_map<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_map.adoc#unordered_map_swap_2[swap](unordered_map<Key, T, Hash, Pred, Alloc>& x,
+              unordered_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    typename unordered_map<K, T, H, P, A>::size_type
+      xref:reference/unordered_map.adoc#unordered_map_erase_if[erase_if](unordered_map<K, T, H, P, A>& c, Predicate pred);
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/unordered_multimap.adoc#unordered_multimap[unordered_multimap];
+
+  // Equality Comparisons
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_multimap.adoc#unordered_multimap_operator[operator++==++](const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
+                    const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_multimap.adoc#unordered_multimap_operator_2[operator!=](const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
+                    const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_multimap.adoc#unordered_multimap_swap_2[swap](unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
+              unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_map =
+      boost::unordered::unordered_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_multimap =
+      boost::unordered::unordered_multimap<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_map;
+using unordered::unordered_multimap;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_map_fwd]
+== `<boost/unordered/unordered_map_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_map_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_map.adoc[`<boost/unordered/unordered_map.hpp>`].

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

@@ -0,0 +1,9 @@
+[#header_unordered_map_fwd_top]
+== `<boost/unordered_map.hpp>` Synopsis
+
+:idprefix: header_unordered_map_top_
+
+[listing,subs="+macros,+quotes"]
+-----
+#include xref:reference/header_unordered_map.adoc[<boost/unordered/unordered_map.hpp>]
+-----

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

@@ -0,0 +1,58 @@
+[#header_unordered_node_map]
+== `<boost/unordered/unordered_node_map.hpp>` Synopsis
+
+:idprefix: header_unordered_node_map_
+
+Defines `xref:reference/unordered_node_map.adoc#unordered_node_map[boost::unordered_node_map]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class T,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<std::pair<const Key, T>>>
+  class xref:reference/unordered_node_map.adoc#unordered_node_map[unordered_node_map];
+
+  // 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,
+                    const unordered_node_map<Key, T, Hash, Pred, Alloc>& y);
+
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_node_map.adoc#unordered_node_map_operator_3[operator!=](const unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
+                    const unordered_node_map<Key, T, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class T, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_node_map.adoc#unordered_node_map_swap_2[swap](unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
+              unordered_node_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class T, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class T,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_node_map =
+      boost::unordered::unordered_node_map<Key, T, Hash, Pred,
+        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_node_map;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_node_map_fwd]
+== `<boost/unordered/unordered_node_map_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_node_map_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>`].

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

@@ -0,0 +1,56 @@
+[#header_unordered_node_set]
+== `<boost/unordered/unordered_node_set.hpp>` Synopsis
+
+:idprefix: header_unordered_node_set_
+
+Defines `xref:reference/unordered_node_set.adoc#unordered_node_set[boost::unordered_node_set]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/unordered_node_set.adoc#unordered_node_set[unordered_node_set];
+
+  // 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,
+                    const unordered_node_set<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_node_set.adoc#unordered_node_set_operator_2[operator!=](const unordered_node_set<Key, Hash, Pred, Alloc>& x,
+                    const unordered_node_set<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_node_set.adoc#unordered_node_set_swap_2[swap](unordered_node_set<Key, Hash, Pred, Alloc>& x,
+              unordered_node_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_node_set =
+      boost::unordered::unordered_node_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_node_set;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_node_set_fwd]
+== `<boost/unordered/unordered_node_set_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_node_set_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`].

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

@@ -0,0 +1,91 @@
+[#header_unordered_set]
+== `<boost/unordered/unordered_set.hpp>` Synopsis
+
+:idprefix: header_unordered_set_
+
+Defines `xref:reference/unordered_set.adoc#unordered_set[boost::unordered_set]`,
+`xref:reference/unordered_multiset.adoc#unordered_multiset[boost::unordered_multiset]`
+and associated functions and alias templates.
+
+[listing,subs="+macros,+quotes"]
+-----
+
+namespace boost {
+namespace unordered {
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/unordered_set.adoc#unordered_set[unordered_set];
+
+  // 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,
+                    const unordered_set<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_set.adoc#unordered_set_operator_2[operator!=](const unordered_set<Key, Hash, Pred, Alloc>& x,
+                    const unordered_set<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_set.adoc#unordered_set_swap_2[swap](unordered_set<Key, Hash, Pred, Alloc>& x,
+              unordered_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    typename unordered_set<K, H, P, A>::size_type
+      xref:reference/unordered_set.adoc#unordered_set_erase_if[erase_if](unordered_set<K, H, P, A>& c, Predicate pred);
+
+  template<class Key,
+           class Hash = boost::hash<Key>,
+           class Pred = std::equal_to<Key>,
+           class Allocator = std::allocator<Key>>
+  class xref:reference/unordered_multiset.adoc#unordered_multiset[unordered_multiset];
+
+  // Equality Comparisons
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_multiset.adoc#unordered_multiset_operator[operator++==++](const unordered_multiset<Key, Hash, Pred, Alloc>& x,
+                    const unordered_multiset<Key, Hash, Pred, Alloc>& y);
+
+  template<class Key, class Hash, class Pred, class Alloc>
+    bool xref:reference/unordered_multiset.adoc#unordered_multiset_operator_2[operator!=](const unordered_multiset<Key, Hash, Pred, Alloc>& x,
+                    const unordered_multiset<Key, Hash, Pred, Alloc>& y);
+
+  // swap
+  template<class Key, class Hash, class Pred, class Alloc>
+    void xref:reference/unordered_multiset.adoc#unordered_multiset_swap_2[swap](unordered_multiset<Key, Hash, Pred, Alloc>& x,
+              unordered_multiset<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+  // Erasure
+  template<class K, class H, class P, class A, class Predicate>
+    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)
+  namespace pmr {
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_set =
+      boost::unordered::unordered_set<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+
+    template<class Key,
+             class Hash = boost::hash<Key>,
+             class Pred = std::equal_to<Key>>
+    using unordered_multiset =
+      boost::unordered::unordered_multiset<Key, Hash, Pred,
+        std::pmr::polymorphic_allocator<Key>>;
+  } // namespace pmr
+
+} // namespace unordered
+
+using unordered::unordered_set;
+using unordered::unordered_multiset;
+
+} // namespace boost
+-----

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

@@ -0,0 +1,7 @@
+[#header_unordered_set_fwd]
+== `<boost/unordered/unordered_set_fwd.hpp>` Synopsis
+
+:idprefix: header_unordered_set_fwd_
+
+Forward declares all the definitions in
+xref:reference/header_unordered_set.adoc[`<boost/unordered/unordered_set.hpp>`].

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

@@ -0,0 +1,9 @@
+[#header_unordered_set_fwd_top]
+== `<boost/unordered_set.hpp>` Synopsis
+
+:idprefix: header_unordered_set_top_
+
+[listing,subs="+macros,+quotes"]
+-----
+#include xref:reference/header_unordered_set.adoc[<boost/unordered/unordered_set.hpp>]
+-----

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

@@ -27,9 +27,11 @@ unordered associative containers.
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_flat_map.hpp>
+// #include xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -272,37 +274,8 @@ namespace boost {
                        Hash, Allocator)
       -> unordered_flat_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_flat_map_operator_2[operator==](const unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_flat_map_operator_3[operator!=](const unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_flat_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_flat_map_swap_2[swap](unordered_flat_map<Key, T, Hash, Pred, Alloc>& x,
-              unordered_flat_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_flat_map<K, T, H, P, A>::size_type
-       xref:#unordered_flat_map_erase_if[erase_if](unordered_flat_map<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_flat_map =
-      boost::unordered_flat_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -27,9 +27,11 @@ unordered associative containers.
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_flat_set.hpp>
+// #include xref:reference/header_unordered_flat_set.adoc[`<boost/unordered/unordered_flat_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -225,36 +227,8 @@ namespace boost {
     unordered_flat_set(std::initializer_list<T>, typename xref:#unordered_flat_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> unordered_flat_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_flat_set_operator_2[operator==](const unordered_flat_set<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_flat_set<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_flat_set_operator_3[operator!=](const unordered_flat_set<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_flat_set<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_flat_set_swap_2[swap](unordered_flat_set<Key, T, Hash, Pred, Alloc>& x,
-              unordered_flat_set<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_flat_set<K, T, H, P, A>::size_type
-       xref:#unordered_flat_set_erase_if[erase_if](unordered_flat_set<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_flat_set =
-      boost::unordered_flat_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -9,9 +9,11 @@
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_map.hpp>
+// #include xref:reference/header_unordered_map.adoc[<boost/unordered/unordered_map.hpp>]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -271,37 +273,8 @@ namespace boost {
                   Allocator)
       -> unordered_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_map_operator_2[operator==](const unordered_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_map_operator_3[operator!=](const unordered_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_map_swap_2[swap](unordered_map<Key, T, Hash, Pred, Alloc>& x,
-              unordered_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_map<K, T, H, P, A>::size_type
-       xref:#unordered_map_erase_if[erase_if](unordered_map<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_map =
-      boost::unordered_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -9,9 +9,11 @@
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_map.hpp>
+// #include xref:reference/header_unordered_map.adoc[<boost/unordered/unordered_map.hpp>]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -238,37 +240,8 @@ namespace boost {
                        Hash, Allocator)
       -> unordered_multimap<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_multimap_operator[operator++==++](const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_multimap_operator_2[operator!=](const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_multimap_swap_2[swap](unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
-              unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_multimap<K, T, H, P, A>::size_type
-      xref:#unordered_multimap_erase_if[erase_if](unordered_multimap<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_multimap =
-      boost::unordered_multimap<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -9,9 +9,11 @@
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_set.hpp>
+// #include xref:reference/header_unordered_set.adoc[<boost/unordered/unordered_set.hpp>]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -228,37 +230,9 @@ namespace boost {
   template<class T, class Hash, class Allocator>
     unordered_multiset(std::initializer_list<T>, typename xref:#unordered_multiset_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> unordered_multiset<T, Hash, std::equal_to<T>, Allocator>;
-      
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_multiset_operator[operator++==++](const unordered_multiset<Key, Hash, Pred, Alloc>& x,
-                    const unordered_multiset<Key, Hash, Pred, Alloc>& y);
 
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_multiset_operator_2[operator!=](const unordered_multiset<Key, Hash, Pred, Alloc>& x,
-                    const unordered_multiset<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#unordered_multiset_swap_2[swap](unordered_multiset<Key, Hash, Pred, Alloc>& x,
-              unordered_multiset<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class H, class P, class A, class Predicate>
-    typename unordered_multiset<K, H, P, A>::size_type
-      xref:#unordered_multiset_erase_if[erase_if](unordered_multiset<K, H, P, A>& c, Predicate pred);
-      
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_multiset =
-      boost::unordered_multiset<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -23,9 +23,11 @@ unordered associative containers.
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_node_map.hpp>
+// #include xref:reference/header_unordered_node_map.adoc[`<boost/unordered/unordered_node_map.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class T,
            class Hash = boost::hash<Key>,
@@ -276,37 +278,8 @@ namespace boost {
                        Hash, Allocator)
       -> unordered_node_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_node_map_operator_2[operator==](const unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_node_map_operator_3[operator!=](const unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_node_map<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_node_map_swap_2[swap](unordered_node_map<Key, T, Hash, Pred, Alloc>& x,
-              unordered_node_map<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_node_map<K, T, H, P, A>::size_type
-       xref:#unordered_node_map_erase_if[erase_if](unordered_node_map<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class T,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_node_map =
-      boost::unordered_node_map<Key, T, Hash, Pred,
-        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -17,15 +17,17 @@ a number of aspects from that of `boost::unordered_set`/`std::unordered_set`:
   - The maximum load factor of the container is managed internally and can't be set by the user.
 
 Other than this, `boost::unordered_node_set` is mostly a drop-in replacement of standard
-unordered associative containers.
+unordered associative containers.   
 
 === Synopsis
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_node_set.hpp>
+// #include xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -230,36 +232,8 @@ namespace boost {
     unordered_node_set(std::initializer_list<T>, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_node_set_operator_2[operator==](const unordered_node_set<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_node_set<Key, T, Hash, Pred, Alloc>& y);
-
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_node_set_operator_3[operator!=](const unordered_node_set<Key, T, Hash, Pred, Alloc>& x,
-                    const unordered_node_set<Key, T, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class T, class Hash, class Pred, class Alloc>
-    void xref:#unordered_node_set_swap_2[swap](unordered_node_set<Key, T, Hash, Pred, Alloc>& x,
-              unordered_node_set<Key, T, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_node_set<K, T, H, P, A>::size_type
-       xref:#unordered_node_set_erase_if[erase_if](unordered_node_set<K, T, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_node_set =
-      boost::unordered_node_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

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

@@ -9,9 +9,11 @@
 
 [listing,subs="+macros,+quotes"]
 -----
-// #include <boost/unordered/unordered_set.hpp>
+// #include xref:reference/header_unordered_set.adoc[<boost/unordered/unordered_set.hpp>]
 
 namespace boost {
+namespace unordered {
+
   template<class Key,
            class Hash = boost::hash<Key>,
            class Pred = std::equal_to<Key>,
@@ -230,36 +232,8 @@ namespace boost {
     unordered_set(std::initializer_list<T>, typename xref:#unordered_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
       -> unordered_set<T, Hash, std::equal_to<T>, Allocator>;
 
-  // Equality Comparisons
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_set_operator[operator++==++](const unordered_set<Key, Hash, Pred, Alloc>& x,
-                    const unordered_set<Key, Hash, Pred, Alloc>& y);
-
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool xref:#unordered_set_operator_2[operator!=](const unordered_set<Key, Hash, Pred, Alloc>& x,
-                    const unordered_set<Key, Hash, Pred, Alloc>& y);
-
-  // swap
-  template<class Key, class Hash, class Pred, class Alloc>
-    void xref:#unordered_set_swap_2[swap](unordered_set<Key, Hash, Pred, Alloc>& x,
-              unordered_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-
-  // Erasure
-  template<class K, class H, class P, class A, class Predicate>
-    typename unordered_set<K, H, P, A>::size_type
-      xref:#unordered_set_erase_if[erase_if](unordered_set<K, H, P, A>& c, Predicate pred);
-
-  // Pmr aliases (C++17 and up)
-  namespace unordered::pmr {
-    template<class Key,
-             class Hash = boost::hash<Key>,
-             class Pred = std::equal_to<Key>>
-    using unordered_set =
-      boost::unordered_set<Key, Hash, Pred,
-        std::pmr::polymorphic_allocator<Key>>;
-  }
-}
+} // namespace unordered
+} // namespace boost
 -----
 
 ---

doc/unordered-playbook.yml

@@ -10,5 +10,5 @@ output:
   dir: html
 ui:
   bundle:
-    url: https://github.com/cmazakas/unordered-ui-bundle/raw/c80db72a7ba804256beb36e3a46d9c7df265d8d7/ui-bundle.zip
+    url: https://github.com/boostorg/unordered-ui-bundle/raw/c80db72a7ba804256beb36e3a46d9c7df265d8d7/ui-bundle.zip
   output_dir: unordered/_