typos/editorial

doc/unordered/buckets.adoc

@@ -52,8 +52,7 @@ h|*Method* h|*Description*
 |`size_type bucket_count() const` 
 |The number of buckets.
 
-2+^h| *Closed-addressing containers only* +
-`boost::unordered_[multi]set`, `boost::unordered_[multi]map` 
+2+^h| *Closed-addressing containers only*
 h|*Method* h|*Description*
 
 |`size_type max_bucket_count() const` 
@@ -132,10 +131,7 @@ h|*Method* h|*Description*
 |`void rehash(size_type n)`
 |Changes the number of buckets so that there at least `n` buckets, and so that the load factor is less than the maximum load factor.
 
-2+^h| *Open-addressing and concurrent containers only* +
-`boost::unordered_flat_set`, `boost::unordered_flat_map` +
-`boost::unordered_node_set`, `boost::unordered_node_map` +
-`boost::concurrent_flat_map`
+2+^h| *Open-addressing and concurrent containers only*
 h|*Method* h|*Description*
 
 |`size_type max_load() const`

doc/unordered/compliance.adoc

@@ -161,7 +161,7 @@ In a non-concurrent unordered container, iterators serve two main purposes:
 * Access to an element previously located via lookup. 
 * Container traversal.
 
-In place of iterators, `boost::unordered_flat_map` uses _internal visitation_
+In place of iterators, `boost::concurrent_flat_map` uses _internal visitation_
 facilities as a thread-safe substitute. Classical operations returning an iterator to an
 element already existing in the container, like for instance:
 

doc/unordered/hash_equality.adoc

@@ -20,14 +20,14 @@ class unordered_map;
 
 The hash function comes first as you might want to change the hash function
 but not the equality predicate. For example, if you wanted to use the
-http://www.isthe.com/chongo/tech/comp/fnv/[FNV-1 hash^] you could write:
+https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash[FNV-1a hash^] you could write:
 
 ```
-boost::unordered_map<std::string, int, hash::fnv_1>
+boost::unordered_map<std::string, int, hash::fnv_1a>
     dictionary;
 ```
 
-There is an link:../../examples/fnv1.hpp[implementation of FNV-1^] in the examples directory.
+There is an link:../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.
 
 If you wish to use a different equality function, you will also need to use a matching hash function. For example, to implement a case insensitive dictionary you need to define a case insensitive equality predicate and hash function:
 

doc/unordered/intro.adoc

@@ -43,7 +43,7 @@ boost::unordered_node_map
 boost::unordered_flat_map
 
 ^.^h|*Concurrent*
-^| N/A
+^|
 ^| `boost::concurrent_flat_map`
 
 |===

doc/unordered/regular.adoc

@@ -6,7 +6,7 @@
 Boost.Unordered closed-addressing containers (`boost::unordered_set`, `boost::unordered_map`,
 `boost::unordered_multiset` and `boost::unordered_multimap`) are fully conformant with the
 C++ specification for unordered associative containers, so for those who know how to use 
-`std::unordered_set`, `std::unordered_map`, etc., their homonyms in Boost:Unordered are
+`std::unordered_set`, `std::unordered_map`, etc., their homonyms in Boost.Unordered are
 drop-in replacements. The interface of open-addressing containers (`boost::unordered_node_set`, 
 `boost::unordered_node_map`, `boost::unordered_flat_set` and `boost::unordered_flat_map`)
 is very similar, but they present some minor differences listed in the dedicated
@@ -62,7 +62,7 @@ invalidated by calls to `insert`, `rehash` and `reserve`.
 As for pointers and references,
 they are never invalidated for node-based containers 
 (`boost::unordered_[multi]set`, `boost::unordered_[multi]map`, `boost::unordered_node_set`, `boost::unordered_node_map`),
-but they will when rehashing occurs for
+but they will be when rehashing occurs for
 `boost::unordered_flat_set` and `boost::unordered_flat_map`: this is because
 these containers store elements directly into their holding buckets, so
 when allocating a new bucket array the elements must be transferred by means of move construction.