diff --git a/docs/containers/maps/reference-flat-map.md b/docs/containers/maps/reference-flat-map.md
new file mode 100644
index 00000000..830345ba
--- /dev/null
+++ b/docs/containers/maps/reference-flat-map.md
@@ -0,0 +1,433 @@
+---
+title: "reference_flat_map"
+---
+
+{{< callout type="info">}}
+  Header: `reference_flat_map.h`  
+  Similar to: `std::reference_flat_map`
+{{< /callout >}}
+
+A fixed capacity reference map based on a sorted vector.  
+The container stores references to objects, rather than the objects themselves.  
+The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.  
+This container is best used for tables that are occasionally updated and spend most of their time being searched.  
+Uses `etl::less` as the default key comparison method.
+
+```cpp
+etl::reference_flat_map<typename TKey, typename TMapped, const size_t SIZE, TKeyCompare = less>
+```
+
+Inherits from `etl::ireference_flat_map<TKey, TMapped, TKeyCompare>`.  
+`etl::ireference_flat_map` may be used as a size independent pointer or reference type for any `etl::reference_flat_map` instance.
+
+## Template deduction guides
+C++17 and above
+
+```cpp
+template <typename... TPairs>
+etl::reference_flat_map(TPairs...)
+```
+
+### Example
+
+```cpp
+etl::reference_flat_map data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
+```
+Defines data as an reference_flat_map of int, of length 4, containing the supplied data.
+
+## Make template
+C++11 and above
+
+```cpp
+template <typename TKey, 
+          typename TMapped, 
+          typename TKeyCompare = etl::less<TKey>, 
+          typename... TPairs>
+constexpr auto make_reference_flat_map(TValues&&... values)
+```
+
+### Example
+auto data = etl::make_reference_flat_map<int. int>(etl::pair{0, 1}, etl::pair{2, 3}, 
+                                                   etl::pair{4, 5}, etl::pair{6, 7});
+
+## Member types
+
+```cpp
+key_type                TKey
+mapped_type             TMapped
+value_type              pair<key_type, mapped_type>
+size_type               size_t
+difference_type         ptrdiff_t
+reference               value_type&
+const_reference         const value_type&
+pointer                 value_type*
+const_pointer           const value_type*
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+reverse_iterator        ETL_OR_STD::reverse_iterator<iterator>
+const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
+```
+
+## Constructor
+
+```cpp
+etl::reference_flat_map<Tkey, TMapped, SIZE, TKeyCompare>()
+```
+**Description**  
+Default constructor.
+
+---
+
+```cpp
+etl::reference_flat_map(const flat_map& other)
+```
+**Description**  
+Copy constructor.
+
+---
+
+```cpp
+template <typename TIterator>
+etl::reference_flat_map<Tkey, TMapped, SIZE, TKeyCompare>(TIterator begin, TIterator end)
+```
+**Description**  
+If the map is full then raises an `etl::reference_flat_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+## Element access
+
+### at
+```cpp
+TMapped& at(const key_type& key)
+const TMapped& at(const key_type& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+mapped_type& at(const K& key)
+const mapped_type& at(const K& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### find
+
+```cpp
+template <typename K>
+iterator find(const key_type& key)
+const_iterator find(const key_type& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+template <typename K>
+iterator find(const K& key)
+const_iterator find(const K& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### lower_bound
+
+```cpp
+iterator lower_bound(const key_type& key)
+const_iterator lower_bound(const key_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+iterator lower_bound(const K& key)
+const_iterator lower_bound(const K& key) const
+```
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### upper_bound
+
+```cpp
+iterator upper_bound(const key_type& key)
+const_iterator upper_bound(const key_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+iterator upper_bound(const K& key)
+const_iterator upper_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### equal_range
+
+```cpp
+pair<iterator, iterator> equal_range(const key_type& key)
+pair<const_iterator, const_iterator> equal_range(const key_type& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+pair<iterator, iterator> equal_range(const K& key)
+pair<const_iterator, const_iterator> equal_range(const K& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### contains
+
+```cpp
+bool contains(const value_type& key) const
+```
+**Description**  
+Check if the container contains the key.
+Since: `20.21.0`
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+bool contains(const K& k) const
+```
+**Description**  
+Check if the container contains the key.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+## Iterators
+
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the map.
+
+---
+
+```cpp
+iterator rbegin()
+const_iterator rbegin() const
+const_iterator crbegin() const
+```
+**Description**  
+Returns a reverse iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator rend()
+const_iterator rend() const
+const_iterator crend() const
+```
+**Description**  
+Returns a reverse iterator to the end of the map.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the map is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the lookup is SIZE, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the lookup.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the map.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the map.
+
+## Modifiers
+
+```cpp
+reference_flat_map& operator = (const reference_flat_map& rhs)
+```
+**Description**  
+Copies the data from another flat map.
+
+---
+
+```cpp
+pair<iterator, bool> insert(const value_type& value)
+```
+**Description**  
+Inserts `value` into the map.
+
+---
+
+```cpp
+iterator insert(iterator position, const value_type& value)
+```
+**Description**  
+Inserts `value` into the map at th esuggested `position`.
+
+---
+
+```cpp
+template <typename TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts values in to the map. If the map is full then raises an `etl::flat_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(const key_type& key)
+```
+**Description**  
+Erase the element with `key`.
+
+---
+
+```cpp
+void erase(iterator i_element)
+```
+**Description**  
+Erase the element at `i_element`.
+
+---
+
+```cpp
+void erase(iterator first, iterator last)
+```
+**Description**  
+Erase elements in the range [`first`, `last`).
+
+---
+
+```cpp
+template <typename K>
+size_t erase(K&& key)
+```
+**Description**  
+Erases values in the map.  
+Since: `20.21.0`
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the lookup to a size of zero.  
+Iterator are not checked for validity.
+
+## Non-member functions
+Lexicographically comparisons
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
+
+## Technical stuff
+
+Reference flat maps are different from the normal version in that the elements are not copied, but linked directly.  
+This means that the lifetime of the element inserted must be as great as that of the map that contains it.  
+Unlike most other reference containers, the map has a finite capacity.  
+
+Flat maps are usually implemented internally as a sorted vector of key/value pairs. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial keys or values.  
+As inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.  
+
+To improve insertion performance ETL reference flat maps are implemented as vectors of pointers to key/value pairs, sorted by key value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.  
+
+The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat map implementation does not have this overhead.  
+
diff --git a/docs/containers/maps/reference-flat-multimap.md b/docs/containers/maps/reference-flat-multimap.md
new file mode 100644
index 00000000..f34bbb67
--- /dev/null
+++ b/docs/containers/maps/reference-flat-multimap.md
@@ -0,0 +1,433 @@
+---
+title: "reference_flat_multimap"
+---
+
+{{< callout type="info">}}
+  Header: `reference_flat_multimap.h`  
+  Similar to: `std::reference_flat_multimap`
+{{< /callout >}}
+
+A fixed capacity reference map based on a sorted vector.  
+The container stores references to objects, rather than the objects themselves.  
+The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.  
+This container is best used for tables that are occasionally updated and spend most of their time being searched.  
+Uses `etl::less` as the default key comparison method.
+
+```cpp
+etl::reference_flat_multimap<typename TKey, typename TMapped, const size_t SIZE, TKeyCompare = less>
+```
+
+Inherits from `etl::ireference_flat_multimap<TKey, TMapped, TKeyCompare>`.  
+`etl::ireference_flat_multimap` may be used as a size independent pointer or reference type for any `etl::reference_flat_multimap` instance.
+
+## Template deduction guides
+C++17 and above
+
+```cpp
+template <typename... TPairs>
+etl::reference_flat_multimap(TPairs...)
+```
+
+### Example
+
+```cpp
+etl::reference_flat_multimap data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
+```
+Defines data as an reference_flat_multimap of int, of length 4, containing the supplied data.
+
+## Make template
+C++11 and above
+
+```cpp
+template <typename TKey, 
+          typename TMapped, 
+          typename TKeyCompare = etl::less<TKey>, 
+          typename... TPairs>
+constexpr auto make_reference_flat_map(TValues&&... values)
+```
+
+### Example
+auto data = etl::make_reference_flat_map<int. int>(etl::pair{0, 1}, etl::pair{2, 3}, 
+                                                   etl::pair{4, 5}, etl::pair{6, 7});
+
+## Member types
+
+```cpp
+key_type                TKey
+mapped_type             TMapped
+value_type              pair<key_type, mapped_type>
+size_type               size_t
+difference_type         ptrdiff_t
+reference               value_type&
+const_reference         const value_type&
+pointer                 value_type*
+const_pointer           const value_type*
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+reverse_iterator        ETL_OR_STD::reverse_iterator<iterator>
+const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
+```
+
+## Constructor
+
+```cpp
+etl::reference_flat_multimap<Tkey, TMapped, SIZE, TKeyCompare>()
+```
+**Description**  
+Default constructor.
+
+---
+
+```cpp
+etl::reference_flat_multimap(const flat_map& other)
+```
+**Description**  
+Copy constructor.
+
+---
+
+```cpp
+template <typename TIterator>
+etl::reference_flat_multimap<Tkey, TMapped, SIZE, TKeyCompare>(TIterator begin, TIterator end)
+```
+**Description**  
+If the map is full then raises an `etl::reference_flat_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+## Element access
+
+### at
+```cpp
+TMapped& at(const key_type& key)
+const TMapped& at(const key_type& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+mapped_type& at(const K& key)
+const mapped_type& at(const K& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### find
+
+```cpp
+template <typename K>
+iterator find(const key_type& key)
+const_iterator find(const key_type& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+template <typename K>
+iterator find(const K& key)
+const_iterator find(const K& key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::flat_map_out_of_range` if the key is not in the table.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### lower_bound
+
+```cpp
+iterator lower_bound(const key_type& key)
+const_iterator lower_bound(const key_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+iterator lower_bound(const K& key)
+const_iterator lower_bound(const K& key) const
+```
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### upper_bound
+
+```cpp
+iterator upper_bound(const key_type& key)
+const_iterator upper_bound(const key_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+iterator upper_bound(const K& key)
+const_iterator upper_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### equal_range
+
+```cpp
+pair<iterator, iterator> equal_range(const key_type& key)
+pair<const_iterator, const_iterator> equal_range(const key_type& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+pair<iterator, iterator> equal_range(const K& key)
+pair<const_iterator, const_iterator> equal_range(const K& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### contains
+
+```cpp
+bool contains(const value_type& key) const
+```
+**Description**  
+Check if the container contains the key.
+Since: `20.21.0`
+
+---
+
+```cpp
+template <typename K, typename KC = TKeyCompare>
+bool contains(const K& k) const
+```
+**Description**  
+Check if the container contains the key.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+## Iterators
+
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the map.
+
+---
+
+```cpp
+iterator rbegin()
+const_iterator rbegin() const
+const_iterator crbegin() const
+```
+**Description**  
+Returns a reverse iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator rend()
+const_iterator rend() const
+const_iterator crend() const
+```
+**Description**  
+Returns a reverse iterator to the end of the map.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the map is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the lookup is SIZE, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the lookup.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the map.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the map.
+
+## Modifiers
+
+```cpp
+reference_flat_multimap& operator = (const reference_flat_multimap& rhs)
+```
+**Description**  
+Copies the data from another flat map.
+
+---
+
+```cpp
+pair<iterator, bool> insert(const value_type& value)
+```
+**Description**  
+Inserts `value` into the map.
+
+---
+
+```cpp
+iterator insert(iterator position, const value_type& value)
+```
+**Description**  
+Inserts `value` into the map at th esuggested `position`.
+
+---
+
+```cpp
+template <typename TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts values in to the map. If the map is full then raises an `etl::flat_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(const key_type& key)
+```
+**Description**  
+Erase the element with `key`.
+
+---
+
+```cpp
+void erase(iterator i_element)
+```
+**Description**  
+Erase the element at `i_element`.
+
+---
+
+```cpp
+void erase(iterator first, iterator last)
+```
+**Description**  
+Erase elements in the range [`first`, `last`).
+
+---
+
+```cpp
+template <typename K>
+size_t erase(K&& key)
+```
+**Description**  
+Erases values in the map.  
+Since: `20.21.0`
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the lookup to a size of zero.  
+Iterator are not checked for validity.
+
+## Non-member functions
+Lexicographically comparisons
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
+
+## Technical stuff
+
+Reference flat maps are different from the normal version in that the elements are not copied, but linked directly.  
+This means that the lifetime of the element inserted must be as great as that of the map that contains it.  
+Unlike most other reference containers, the map has a finite capacity.  
+
+Flat maps are usually implemented internally as a sorted vector of key/value pairs. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial keys or values.  
+As inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.  
+
+To improve insertion performance ETL reference flat maps are implemented as vectors of pointers to key/value pairs, sorted by key value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.  
+
+The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat map implementation does not have this overhead.  
+
diff --git a/docs/containers/maps/unordered-map.md b/docs/containers/maps/unordered-map.md
new file mode 100644
index 00000000..bf2810ad
--- /dev/null
+++ b/docs/containers/maps/unordered-map.md
@@ -0,0 +1,375 @@
+---
+title: "unordered_map"
+---
+
+{{< callout type="info">}}
+  Header: `unordered_map.h`  
+  Similar to: `std::unordered_map`
+{{< /callout >}}
+
+A fixed capacity unordered map.
+Uses `std::less` as the default key comparison method.
+
+This page just describes etl::unordered_map.
+
+```cpp
+template <typename TKey, 
+          typename TValue, 
+          size_t   MAX_SIZE, 
+          size_t   MAX_BUCKETS = MAX_SIZE, 
+          typename THash = etl::hash<TKey>, 
+          typename TKeyEqual = etl::equal_to<TKey>>
+class unordered_map
+```
+
+Inherits from  `iunordered_map<TKey, TValue, THash, TKeyEqual>`.  
+`etl::iunordered_map` may be used as a size independent pointer or reference type for any `etl::unordered_map` instance.
+
+## Template deduction guides
+C++17 and above
+
+```cpp
+template <typename... TPairs>
+etl::unordered_map(TPairs...)
+```
+
+### Example
+```cpp
+etl::unordered_map data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
+```
+Defines data as an unordered map of `int`/`int` pairs, of length 4, containing the supplied data.
+
+## Make template
+C++11 and above
+
+```cpp
+template <typename TKey, 
+          typename TValue, 
+          typename THash       = etl::hash<TKey>, 
+          typename TKeyEqual   = etl::equal_to<TKey>
+          typename... TPairs>
+constexpr auto make_unordered_map(TValues&&... values)
+```
+
+### Example
+```cpp
+auto data = etl::make_unordered_map<int, int>(etl::pair{0, 1}, etl::pair{2, 3}, 
+                                              etl::pair{4, 5}, etl::pair{6, 7});
+```
+
+## Member types
+
+```cpp
+value_type              pair<const TKey, T>
+key_type                The type of the key value
+mapped_type             The type of the mapped value
+hasher                  The type used to hash the key
+key_equal               The functor used to compare keys
+reference               A reference to a value_type
+const_reference         A reference to a const value_type
+pointer                 A pointer to a value_type
+const_pointer           A pointer to a const value_type
+size_type               The type used for size information
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+local_iterator          Iterator to a bucket
+local_const_iterator    A const iterator to a bucket
+```
+
+## Constructor
+
+```cpp
+unordered_map()
+```
+**Description**  
+Default constructor
+
+---
+
+```cpp
+unordered_map(const unordered_map& other)
+```
+**Description**  
+Copy constructor
+
+---
+
+```cpp
+template <typename TIterator>
+unordered_map(TIterator begin, TIterator end)
+```
+**Description**  
+Construct from a range
+
+## Element access
+
+```cpp
+mapped_type& at(key_parameter_t key)
+const mapped_type& at(key_parameter_t key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::unordered_map_out_of_range` if the key is not in the table.  
+If assert or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+mapped_type& operator[](key_parameter_t key)
+```
+**Description**  
+Returns a reference to the indexed element.  
+If the key does not exist then one is created using the default constructor.  
+If the map is full then emits an `etl::unordered_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+iterator find(key_parameter_t key);
+const_iterator find (key_parameter_t key) const
+```
+**Description**  
+Searches the container for an element with a key equivalent to key and returns an iterator to it if found, otherwise it returns an iterator to `etl::unordered_map::end()`.
+
+---
+
+```cpp
+bool contains(const_key_reference key) const
+```
+**Description**  
+Check if the map contains the key.
+
+---
+
+```cpp
+template <typename K, typename KE = TKeyEqual>
+bool contains(const K& key) const
+```
+**Description**  
+Check if the map contains the key.  
+Enabled if the comparator is transparent.
+
+---
+
+```cpp
+size_type count(key_parameter_t key) const
+```
+**Description**  
+Count elements with a specific key.  
+Searches the container for elements with a key equivalent to key and returns the number of matches
+
+---
+
+```cpp
+iterator lower_bound(key_parameter_t key)
+const_iterator lower_bound(key_parameter_t key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+---
+
+```cpp
+iterator upper_bound(key_parameter_t key)
+const_iterator upper_bound(key_parameter_t key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after key.
+
+---
+
+```cpp
+pair<iterator, iterator> equal_range(key_parameter_t key)
+pair<const_iterator, const_iterator> equal_range(key_parameter_t key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to key.
+
+## Iterators
+
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the map.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the map is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the map is `SIZE`, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the map.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the map.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the map.
+
+---
+
+```cpp
+size_type get_bucket_index(key_parameter_t key) const
+```
+**Description**  
+Returns the bucket index for the key.
+
+---
+
+```cpp
+size_type bucket_size(key_parameter_t key) const
+```
+**Description**  
+Returns the size of the bucket key.
+
+---
+
+```cpp
+size_type max_bucket_count() const
+```
+**Description**  
+Returns the maximum number of the buckets the container can hold.
+
+---
+
+```cpp
+float load_factor() const
+```
+**Description**  
+Returns the load factor = size / bucket_count
+
+---
+
+```cpp
+hasher hash_function() const
+```
+**Description**  
+Returns the function that hashes the keys.
+
+---
+
+```cpp
+key_equal key_eq() const
+```
+**Description**  
+Returns the function that compares the keys.
+
+## Modifiers
+
+```cpp
+template <typename TIterator>
+void assign(TIterator first, TIterator last)
+```
+**Description**  
+Assigns elements from the range [`first`, `last`)].  
+Clears the container before assigning.
+
+---
+
+```cpp
+pair<iterator, bool> insert(const value_type& key_value_pair)
+iterator insert(const_iterator, const value_type& key_value_pair)
+```
+**Description**  
+Assigns elements from the range [`first`, `last`)].  
+Clears the container before assigning.
+
+---
+
+```cpp
+template <template TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts the range [`first`, `last`)] into the map.  
+If the map is full then emits an `etl::unordered_map_full error`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(key_parameter_t key)
+```
+**Description**  
+Removes the element with the key `key`.
+
+---
+
+```cpp
+iterator erase(const_iterator ielement)
+```
+**Description**  
+Removes the element with the key `key`.
+
+---
+
+```cpp
+iterator erase(const_iterator first, const_iterator last)
+```
+**Description**  
+Erases values in the map.  
+Iterator are not checked for validity.
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the map to a size of zero.
+
+## Non-member functions
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
diff --git a/docs/containers/maps/unordered-multimap.md b/docs/containers/maps/unordered-multimap.md
new file mode 100644
index 00000000..5e50cba3
--- /dev/null
+++ b/docs/containers/maps/unordered-multimap.md
@@ -0,0 +1,373 @@
+---
+title: "unordered_multimap"
+---
+
+{{< callout type="info">}}
+  Header: `unordered_multimap.h`  
+  Similar to: `std::unordered_multimap`
+{{< /callout >}}
+
+A fixed capacity unordered map.
+Uses `std::less` as the default key comparison method.
+
+```cpp
+template <typename TKey, 
+          typename TValue, 
+          size_t   MAX_SIZE, 
+          size_t   MAX_BUCKETS = MAX_SIZE, 
+          typename THash = etl::hash<TKey>, 
+          typename TKeyEqual = etl::equal_to<TKey>>
+class unordered_multimap
+```
+
+Inherits from  `iunordered_map<TKey, TValue, THash, TKeyEqual>`.  
+`etl::iunordered_map` may be used as a size independent pointer or reference type for any `etl::unordered_multimap` instance.
+
+## Template deduction guides
+C++17 and above
+
+```cpp
+template <typename... TPairs>
+etl::unordered_multimap(TPairs...)
+```
+
+### Example
+```cpp
+etl::unordered_multimap data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
+```
+Defines data as an unordered map of `int`/`int` pairs, of length 4, containing the supplied data.
+
+## Make template
+C++11 and above
+
+```cpp
+template <typename TKey, 
+          typename TValue, 
+          typename THash       = etl::hash<TKey>, 
+          typename TKeyEqual   = etl::equal_to<TKey>
+          typename... TPairs>
+constexpr auto make_unordered_map(TValues&&... values)
+```
+
+### Example
+```cpp
+auto data = etl::make_unordered_map<int, int>(etl::pair{0, 1}, etl::pair{2, 3}, 
+                                              etl::pair{4, 5}, etl::pair{6, 7});
+```
+
+## Member types
+
+```cpp
+value_type              pair<const TKey, T>
+key_type                The type of the key value
+mapped_type             The type of the mapped value
+hasher                  The type used to hash the key
+key_equal               The functor used to compare keys
+reference               A reference to a value_type
+const_reference         A reference to a const value_type
+pointer                 A pointer to a value_type
+const_pointer           A pointer to a const value_type
+size_type               The type used for size information
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+local_iterator          Iterator to a bucket
+local_const_iterator    A const iterator to a bucket
+```
+
+## Constructor
+
+```cpp
+unordered_multimap()
+```
+**Description**  
+Default constructor
+
+---
+
+```cpp
+unordered_multimap(const unordered_multimap& other)
+```
+**Description**  
+Copy constructor
+
+---
+
+```cpp
+template <typename TIterator>
+unordered_multimap(TIterator begin, TIterator end)
+```
+**Description**  
+Construct from a range
+
+## Element access
+
+```cpp
+mapped_type& at(key_parameter_t key)
+const mapped_type& at(key_parameter_t key) const
+```
+**Description**  
+Returns a reference or const reference to the indexed element.  
+Raises an `etl::unordered_map_out_of_range` if the key is not in the table.  
+If assert or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+mapped_type& operator[](key_parameter_t key)
+```
+**Description**  
+Returns a reference to the indexed element.  
+If the key does not exist then one is created using the default constructor.  
+If the map is full then emits an `etl::unordered_map_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+iterator find(key_parameter_t key);
+const_iterator find (key_parameter_t key) const
+```
+**Description**  
+Searches the container for an element with a key equivalent to key and returns an iterator to it if found, otherwise it returns an iterator to `etl::unordered_multimap::end()`.
+
+---
+
+```cpp
+bool contains(const_key_reference key) const
+```
+**Description**  
+Check if the map contains the key.
+
+---
+
+```cpp
+template <typename K, typename KE = TKeyEqual>
+bool contains(const K& key) const
+```
+**Description**  
+Check if the map contains the key.  
+Enabled if the comparator is transparent.
+
+---
+
+```cpp
+size_type count(key_parameter_t key) const
+```
+**Description**  
+Count elements with a specific key.  
+Searches the container for elements with a key equivalent to key and returns the number of matches
+
+---
+
+```cpp
+iterator lower_bound(key_parameter_t key)
+const_iterator lower_bound(key_parameter_t key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
+
+---
+
+```cpp
+iterator upper_bound(key_parameter_t key)
+const_iterator upper_bound(key_parameter_t key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+---
+
+```cpp
+pair<iterator, iterator> equal_range(key_parameter_t key)
+pair<const_iterator, const_iterator> equal_range(key_parameter_t key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+## Iterators
+
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the map.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the map.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the map is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the map is `SIZE`, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the map.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the map.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the map.
+
+---
+
+```cpp
+size_type get_bucket_index(key_parameter_t key) const
+```
+**Description**  
+Returns the bucket index for the key.
+
+---
+
+```cpp
+size_type bucket_size(key_parameter_t key) const
+```
+**Description**  
+Returns the size of the bucket key.
+
+---
+
+```cpp
+size_type max_bucket_count() const
+```
+**Description**  
+Returns the maximum number of the buckets the container can hold.
+
+---
+
+```cpp
+float load_factor() const
+```
+**Description**  
+Returns the load factor = size / bucket_count
+
+---
+
+```cpp
+hasher hash_function() const
+```
+**Description**  
+Returns the function that hashes the keys.
+
+---
+
+```cpp
+key_equal key_eq() const
+```
+**Description**  
+Returns the function that compares the keys.
+
+## Modifiers
+
+```cpp
+template <typename TIterator>
+void assign(TIterator first, TIterator last)
+```
+**Description**  
+Assigns elements from the range [`first`, `last`)].  
+Clears the container before assigning.
+
+---
+
+```cpp
+pair<iterator, bool> insert(const value_type& key_value_pair)
+iterator insert(const_iterator, const value_type& key_value_pair)
+```
+**Description**  
+Assigns elements from the range [`first`, `last`)].  
+Clears the container before assigning.
+
+---
+
+```cpp
+template <template TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts the range [`first`, `last`)] into the map.  
+If the map is full then emits an `etl::unordered_map_full error`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(key_parameter_t key)
+```
+**Description**  
+Removes the element with the key `key`.
+
+---
+
+```cpp
+iterator erase(const_iterator ielement)
+```
+**Description**  
+Removes the element with the key `key`.
+
+---
+
+```cpp
+iterator erase(const_iterator first, const_iterator last)
+```
+**Description**  
+Erases values in the map.  
+Iterator are not checked for validity.
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the map to a size of zero.
+
+## Non-member functions
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
diff --git a/docs/containers/sets/flat_multiset.md b/docs/containers/sets/flat-multiset.md
similarity index 100%
rename from docs/containers/sets/flat_multiset.md
rename to docs/containers/sets/flat-multiset.md
diff --git a/docs/containers/sets/flat_set.md b/docs/containers/sets/flat-set.md
similarity index 100%
rename from docs/containers/sets/flat_set.md
rename to docs/containers/sets/flat-set.md
diff --git a/docs/containers/sets/reference-flat-multiset.md b/docs/containers/sets/reference-flat-multiset.md
new file mode 100644
index 00000000..467f40e6
--- /dev/null
+++ b/docs/containers/sets/reference-flat-multiset.md
@@ -0,0 +1,358 @@
+---
+title: "reference_flat_set"
+---
+
+A fixed capacity set based on a sorted vector.  
+The container stores references to objects, rather than the objects themselves.  
+The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.  
+This container is best used for tables that are occasionally updated and spend most of their time being searched.  
+The interface is most similar to `std::set`.  
+Uses `etl::less` as the default key comparison method.  
+
+```cpp
+etl::reference_flat_set<typename T, const size_t SIZE, TCompare = etl::less>
+```
+
+Inherits from `etl::ireference_flat_set<T, TCompare>`.  
+`etl::ireference_flat_set` may be used as a size independent pointer or reference type for any `etl::reference_flat_set` instance.
+
+## Template deduction guides
+C++17 and above
+
+template <typename... T>
+etl::reference_flat_set(T...)
+
+### Example
+etl::reference_flat_setdata{ 0, 1, 2, 3, 4, 5, 6, 7 };
+Defines data as a set of int/int pairs, of length 8, containing the supplied data.
+
+## Make template
+C++11 and above
+template <typename TKey
+          typename... T>
+constexpr auto make_reference_flat_set(T&&... values)
+
+### Example
+auto data = etl::make_reference_flat_set<int>(0, 1, 2, 3, 4, 5, 6, 7);
+
+## Member types
+
+```cpp
+key_type                T
+value_type              T
+size_type               size_t
+difference_type         ptrdiff_t
+reference               value_type&
+const_reference         const value_type&
+pointer                 value_type*
+const_pointer           const value_type*
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+reverse_iterator        ETL_OR_STD:reverse_iterator<iterator>
+const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
+```
+
+## Constructor
+
+```cpp
+etl::flat_set<T, SIZE, TCompare>();
+```
+**Description**  
+
+---
+
+```cpp
+etl::flat_set(const flat_set& other)
+```
+**Description**  
+
+---
+
+```cpp
+template <typename TIterator>
+etl::flat_set<T, SIZE, TCompare>(TIterator begin, TIterator end);
+```
+**Description**  
+If the set is full then raises an `etl::reference_flat_set_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+## Iterators
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the set.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the set.
+
+---
+
+```cpp
+iterator rbegin()
+const_iterator rbegin() const
+const_iterator crbegin() const
+```
+**Description**  
+Returns a reverse iterator to the beginning of the set.
+
+---
+
+```cpp
+iterator rend()
+const_iterator rend() const
+const_iterator crend() const
+```
+**Description**  
+Returns a reverse iterator to the end of the set.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the set is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the lookup is `SIZE`, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the lookup.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the set.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the set.
+
+## Modifiers
+
+```cpp
+flat_set& operator = (const flat_set& rhs)
+```
+**Description**  
+Copies the data from another flat set.
+
+---
+
+```cpp
+ETL_OR_STD::pair<iterator, bool> insert(const value_type& value)
+iterator insert(iterator position, const value_type& value)
+```
+**Description**  
+
+---
+
+```cpp
+template <typename TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts values in to the set.  
+If the set is full then raises an `etl::reference_flat_set_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(const value_type& key)
+void erase(iterator i_element)
+void erase(iterator first, iterator last)
+```
+**Description**  
+Erases values in the set.  
+Iterators are not checked for validity.
+
+Since: 20.21.0
+```cpp
+template <typename K>
+size_t erase(K&& key)
+```
+**Description**  
+Erases values in the map.
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the lookup to a size of zero.
+
+## Search
+
+### find
+
+```cpp
+iterator find(const value_type& key)
+const_iterator find(const value_type& key) const
+```
+**Description**  
+Finds the element that contains `key`, or `end()` if not found,
+
+
+```cpp
+template <typename K>
+iterator find(const K& key)
+const_iterator find(const K& key) const
+```
+**Description**  
+Finds the element that contains `key`, or `end()` if not found,
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### lower_bound
+
+```cpp
+iterator lower_bound(const value_type& key)
+const_iterator lower_bound(const value_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before `key` (i.e., either it is equivalent or goes after).
+
+---
+
+Since: 20.21.0
+C++11 or above
+```cpp
+template <typename K>
+iterator lower_bound(const K& key)
+const_iterator lower_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before `key` (i.e., either it is equivalent or goes after).
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### upper_bound
+
+```cpp
+iterator upper_bound(const value_type& key)
+const_iterator upper_bound(const value_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+---
+
+```cpp
+template <typename K>
+iterator upper_bound(const K& key)
+const_iterator upper_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### equal_range
+
+```cpp
+ETL_OR_STD::pair<iterator, iterator> equal_range(const value_type& key)
+ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const value_type& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+---
+
+```cpp
+template <typename K>
+pair<iterator, iterator> equal_range(const K& key)
+pair<const_iterator, const_iterator> equal_range(const K& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### contains
+
+```cpp
+bool contains(const value_type&  key) const
+```
+**Description**  
+Check if the container contains the key.
+
+Since: 20.21.0
+C++11 or above
+For comparators that define is_transparent.
+
+```cpp
+template <typename K>
+bool contains(const K& k) const
+```
+**Description**  
+Check if the container contains the key.
+
+Since: 20.21.0
+C++11 or above
+For comparators that define is_transparent.
+
+## Non-member functions
+Lexicographically comparisons
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
+
+## How it works
+
+Reference flat sets are different from the normal version in that the elements are not copied, but linked directly.  
+This means that the lifetime of the element inserted must be as great as that of the set that contains it.  
+Unlike most other reference containers, the set has a finite capacity.  
+
+Flat sets are usually implemented internally as a sorted vector of values. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial values.  
+As Inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.  
+
+To improve insertion performance ETL reference flat sets are implemented as vectors of pointers to values, sorted by value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.  
+
+The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat set implementation does not have this overhead.  
diff --git a/docs/containers/sets/reference-flat-set.md b/docs/containers/sets/reference-flat-set.md
new file mode 100644
index 00000000..467f40e6
--- /dev/null
+++ b/docs/containers/sets/reference-flat-set.md
@@ -0,0 +1,358 @@
+---
+title: "reference_flat_set"
+---
+
+A fixed capacity set based on a sorted vector.  
+The container stores references to objects, rather than the objects themselves.  
+The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.  
+This container is best used for tables that are occasionally updated and spend most of their time being searched.  
+The interface is most similar to `std::set`.  
+Uses `etl::less` as the default key comparison method.  
+
+```cpp
+etl::reference_flat_set<typename T, const size_t SIZE, TCompare = etl::less>
+```
+
+Inherits from `etl::ireference_flat_set<T, TCompare>`.  
+`etl::ireference_flat_set` may be used as a size independent pointer or reference type for any `etl::reference_flat_set` instance.
+
+## Template deduction guides
+C++17 and above
+
+template <typename... T>
+etl::reference_flat_set(T...)
+
+### Example
+etl::reference_flat_setdata{ 0, 1, 2, 3, 4, 5, 6, 7 };
+Defines data as a set of int/int pairs, of length 8, containing the supplied data.
+
+## Make template
+C++11 and above
+template <typename TKey
+          typename... T>
+constexpr auto make_reference_flat_set(T&&... values)
+
+### Example
+auto data = etl::make_reference_flat_set<int>(0, 1, 2, 3, 4, 5, 6, 7);
+
+## Member types
+
+```cpp
+key_type                T
+value_type              T
+size_type               size_t
+difference_type         ptrdiff_t
+reference               value_type&
+const_reference         const value_type&
+pointer                 value_type*
+const_pointer           const value_type*
+iterator                Random access iterator
+const_iterator          Constant random access iterator
+reverse_iterator        ETL_OR_STD:reverse_iterator<iterator>
+const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
+```
+
+## Constructor
+
+```cpp
+etl::flat_set<T, SIZE, TCompare>();
+```
+**Description**  
+
+---
+
+```cpp
+etl::flat_set(const flat_set& other)
+```
+**Description**  
+
+---
+
+```cpp
+template <typename TIterator>
+etl::flat_set<T, SIZE, TCompare>(TIterator begin, TIterator end);
+```
+**Description**  
+If the set is full then raises an `etl::reference_flat_set_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+## Iterators
+```cpp
+iterator begin()
+const_iterator begin() const
+const_iterator cbegin() const
+```
+**Description**  
+Returns an iterator to the beginning of the set.
+
+---
+
+```cpp
+iterator end()
+const_iterator end() const
+const_iterator cend() const
+```
+**Description**  
+Returns an iterator to the end of the set.
+
+---
+
+```cpp
+iterator rbegin()
+const_iterator rbegin() const
+const_iterator crbegin() const
+```
+**Description**  
+Returns a reverse iterator to the beginning of the set.
+
+---
+
+```cpp
+iterator rend()
+const_iterator rend() const
+const_iterator crend() const
+```
+**Description**  
+Returns a reverse iterator to the end of the set.
+
+## Capacity
+
+```cpp
+bool empty() const
+```
+**Description**  
+Returns `true` if the size of the set is zero, otherwise `false`.
+
+---
+
+```cpp
+bool full() const
+```
+**Description**  
+Returns `true` if the size of the lookup is `SIZE`, otherwise `false`.
+
+---
+
+```cpp
+size_t size() const
+```
+**Description**  
+Returns the size of the lookup.
+
+---
+
+```cpp
+size_t max_size() const
+```
+**Description**  
+Returns the maximum possible size of the set.
+
+---
+
+```cpp
+size_t available() const
+```
+**Description**  
+Returns the remaining available capacity in the set.
+
+## Modifiers
+
+```cpp
+flat_set& operator = (const flat_set& rhs)
+```
+**Description**  
+Copies the data from another flat set.
+
+---
+
+```cpp
+ETL_OR_STD::pair<iterator, bool> insert(const value_type& value)
+iterator insert(iterator position, const value_type& value)
+```
+**Description**  
+
+---
+
+```cpp
+template <typename TIterator>
+void insert(TIterator first, TIterator last)
+```
+**Description**  
+Inserts values in to the set.  
+If the set is full then raises an `etl::reference_flat_set_full`.  
+If asserts or exceptions are not enabled then undefined behaviour occurs.
+
+---
+
+```cpp
+size_t erase(const value_type& key)
+void erase(iterator i_element)
+void erase(iterator first, iterator last)
+```
+**Description**  
+Erases values in the set.  
+Iterators are not checked for validity.
+
+Since: 20.21.0
+```cpp
+template <typename K>
+size_t erase(K&& key)
+```
+**Description**  
+Erases values in the map.
+
+---
+
+```cpp
+void clear()
+```
+**Description**  
+Clears the lookup to a size of zero.
+
+## Search
+
+### find
+
+```cpp
+iterator find(const value_type& key)
+const_iterator find(const value_type& key) const
+```
+**Description**  
+Finds the element that contains `key`, or `end()` if not found,
+
+
+```cpp
+template <typename K>
+iterator find(const K& key)
+const_iterator find(const K& key) const
+```
+**Description**  
+Finds the element that contains `key`, or `end()` if not found,
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### lower_bound
+
+```cpp
+iterator lower_bound(const value_type& key)
+const_iterator lower_bound(const value_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before `key` (i.e., either it is equivalent or goes after).
+
+---
+
+Since: 20.21.0
+C++11 or above
+```cpp
+template <typename K>
+iterator lower_bound(const K& key)
+const_iterator lower_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is not considered to go before `key` (i.e., either it is equivalent or goes after).
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### upper_bound
+
+```cpp
+iterator upper_bound(const value_type& key)
+const_iterator upper_bound(const value_type& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+---
+
+```cpp
+template <typename K>
+iterator upper_bound(const K& key)
+const_iterator upper_bound(const K& key) const
+```
+**Description**  
+Returns an iterator pointing to the first element in the container whose key is considered to go after `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### equal_range
+
+```cpp
+ETL_OR_STD::pair<iterator, iterator> equal_range(const value_type& key)
+ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(const value_type& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+---
+
+```cpp
+template <typename K>
+pair<iterator, iterator> equal_range(const K& key)
+pair<const_iterator, const_iterator> equal_range(const K& key) const
+```
+**Description**  
+Returns the bounds of a range that includes all the elements in the container which have a key equivalent to `key`.
+
+C++11 or above.  
+For comparators that define `is_transparent`.  
+Since: `20.21.0`
+
+### contains
+
+```cpp
+bool contains(const value_type&  key) const
+```
+**Description**  
+Check if the container contains the key.
+
+Since: 20.21.0
+C++11 or above
+For comparators that define is_transparent.
+
+```cpp
+template <typename K>
+bool contains(const K& k) const
+```
+**Description**  
+Check if the container contains the key.
+
+Since: 20.21.0
+C++11 or above
+For comparators that define is_transparent.
+
+## Non-member functions
+Lexicographically comparisons
+
+```cpp
+operator ==
+```
+**Description**  
+`true` if the contents of the maps are equal, otherwise `false`.
+
+---
+
+```cpp
+operator !=
+```
+**Description**  
+`true` if the contents of the maps are not equal, otherwise `false`.
+
+## How it works
+
+Reference flat sets are different from the normal version in that the elements are not copied, but linked directly.  
+This means that the lifetime of the element inserted must be as great as that of the set that contains it.  
+Unlike most other reference containers, the set has a finite capacity.  
+
+Flat sets are usually implemented internally as a sorted vector of values. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial values.  
+As Inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.  
+
+To improve insertion performance ETL reference flat sets are implemented as vectors of pointers to values, sorted by value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.  
+
+The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat set implementation does not have this overhead.  
diff --git a/docs/raw/containers/reference_flat_map.txt b/docs/raw/containers/reference_flat_map.txt
deleted file mode 100644
index 1843ac73..00000000
--- a/docs/raw/containers/reference_flat_map.txt
+++ /dev/null
@@ -1,256 +0,0 @@
-reference_flat_map
-reference_flat_multmap
-
-A fixed capacity reference map based on a sorted vector.
-The container stores references to objects, rather than the objects themselves.
-The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.
-This container is best used for tables that are occasionally updated and spend most of their time being searched.
-The interface is most similar to std::map.
-Uses etl::less as the default key comparison method.
-
-etl::reference_flat_map<typename TKey, typename TMapped, const size_t SIZE, TKeyCompare = less>
-
-Inherits from etl::ireference_flat_map<TKey, TMapped, TKeyCompare>
-etl::ireference_flat_map may be used as a size independent pointer or reference type for any etl::reference_flat_map instance.
-____________________________________________________________________________________________________
-Template deduction guides
-C++17 and above
-
-template <typename... TPairs>
-etl::reference_flat_map(TPairs...)
-
-Example
-etl::reference_flat_map data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
-Defines data as an reference_flat_map of int/int pairs, of length 4, containing the supplied data.
-____________________________________________________________________________________________________
-Make template
-C++11 and above
-template <typename TKey, 
-          typename TMapped, 
-          typename TKeyCompare = etl::less<TKey>, 
-          typename... TPairs>
-constexpr auto make_reference_flat_map(TValues&&... values)
-
-Example
-auto data = etl::make_reference_flat_map<int. int>(etl::pair{0, 1}, etl::pair{2, 3}, 
-                                                   etl::pair{4, 5}, etl::pair{6, 7});
-____________________________________________________________________________________________________
-Member types
-
-key_type                TKey
-mapped_type             TMapped
-value_type              pair<key_type, mapped_type>
-size_type               size_t
-difference_type         ptrdiff_t
-reference               value_type&
-const_reference         const value_type&
-pointer                 value_type*
-const_pointer           const value_type*
-iterator                Random access iterator
-const_iterator          Constant random access iterator
-reverse_iterator        ETL_OR_STD::reverse_iterator<iterator>
-const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
-
-____________________________________________________________________________________________________
-Constructor
-
-etl::reference_flat_map<Tkey, TMapped, SIZE, TKeyCompare>();
-
-etl::reference_flat_map(const flat_map& other)
-
-template <typename TIterator>
-etl::reference_flat_map<Tkey, TMapped, SIZE, TKeyCompare>(TIterator begin, TIterator end);
-If the map is full then emits an etl::reference_flat_map_full. If asserts or exceptions are not enabled then undefined behaviour occurs.
-
-____________________________________________________________________________________________________
-Element access
-
-TMapped& at(key_parameter_t key)
-const TMapped& at(key_parameter_t key) const
-Returns a reference or const reference to the indexed element.
-Emits an etl::flat_map_out_of_range if the key is not in the table.  If asserts or exceptions are not enabled then undefined behaviour occurs.
-
-20.21.0
-C++11 or above
-For comparators that define is_transparent.
-
-template <typename K>
-TMapped& at(key_parameter_t key)
-
-template <typename K>
-const TMapped& at(key_parameter_t key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-For comparators that define is_transparent.
-
-template <typename K>
-iterator find(const K& key)
-
-template <typename K>
-const_iterator find(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-iterator lower_bound(const K& key)
-
-template <typename K>
-const_iterator lower_bound(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-iterator upper_bound(const K& key)
-
-template <typename K>
-const_iterator upper_bound(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-pair<iterator, iterator> equal_range(const K& key)
-
-template <typename K>pair<const_iterator, const_iterator> equal_range(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-bool contains(key_value_parameter_t  key) const
-Check if the container contains the key.
-
-20.21.0
-C++11 or above
-For comparators that define is_transparent.
-template <typename K>
-bool contains(const K& k) const
-Check if the container contains the key.
-____________________________________________________________________________________________________
-Iterators
-
-iterator begin()
-const_iterator begin() const
-const_iterator cbegin() const
-Returns an iterator to the beginning of the map.
-____________________________________________________________________________________________________
-iterator end()
-const_iterator end() const
-const_iterator cend() const
-Returns an iterator to the end of the map.
-____________________________________________________________________________________________________
-iterator rbegin()
-const_iterator rbegin() const
-const_iterator crbegin() const
-Returns a reverse iterator to the beginning of the map.
-____________________________________________________________________________________________________
-iterator rend()
-const_iterator rend() const
-const_iterator crend() const
-Returns a reverse iterator to the end of the map.
-
-____________________________________________________________________________________________________
-Capacity
-
-bool empty() const
-Returns true if the size of the map is zero, otherwise false.
-____________________________________________________________________________________________________
-bool full() const
-Returns true if the size of the lookup is SIZE, otherwise false.
-____________________________________________________________________________________________________
-size_t size() const
-Returns the size of the lookup.
-____________________________________________________________________________________________________
-size_t max_size() const
-Returns the maximum possible size of the map.
-____________________________________________________________________________________________________
-size_t available() const
-Returns the remaining available capacity in the map.
-____________________________________________________________________________________________________
-Modifiers
-
-reference_flat_map& operator = (const reference_flat_map& rhs)
-Copies the data from another flat map.
-____________________________________________________________________________________________________
-
-pair<iterator, bool> insert(const value_type& value)
-
-iterator insert(iterator position, const value_type& value)
-
-template <typename TIterator>
-void insert(TIterator first, TIterator last)
-Inserts values in to the map. If the map is full then emits an etl::flat_map_full.
-If asserts or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-size_t erase(key_value_parameter_t key)
-
-void erase(iterator i_element)
-
-void erase(iterator first, iterator last)
-
-20.21.0
-template <typename K>
-size_t erase(K&& key)
-Erases values in the map.
-____________________________________________________________________________________________________
-void clear();
-Clears the lookup to a size of zero.
-Iterator are not checked for validity.
-____________________________________________________________________________________________________
-Search
-
-iterator find(key_value_parameter_t key)
-const_iterator find(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-iterator lower_bound(key_value_parameter_t key)
-const_iterator lower_bound(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-iterator upper_bound(key_value_parameter_t key)
-const_iterator upper_bound(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-pair<iterator, iterator> equal_range(key_value_parameter_t key)
-pair<const_iterator , const_iterator > equal_range(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-20.21.0
-For comparators that define is_transparent.
-
-template <typename K>
-iterator find(const K& key)
-
-template <typename K>
-const_iterator find(const K& key) const
-
-template <typename K>
-iterator lower_bound(const K& key)
-
-template <typename K>
-const_iterator lower_bound(const K& key) const
-
-template <typename K>
-iterator upper_bound(const K& key)
-
-template <typename K>
-const_iterator upper_bound(const K& key) const
-
-template <typename K>
-pair<iterator, iterator> equal_range(const K& key)
-
-template <typename K>
-pair<const_iterator, const_iterator> equal_range(const K& key) const
-____________________________________________________________________________________________________
-Non-member functions
-Lexicographically comparisons
-
-==  true if the contents of the maps are equal, otherwise false.
-!=  true if the contents of the maps are not equal, otherwise false.
-____________________________________________________________________________________________________
-Technical stuff
-
-Reference flat maps are different from the normal version in that the elements are not copied, but linked directly.
-This means that the lifetime of the element inserted must be as great as that of the map that contains it.
-Unlike most other reference containers, the map has a finite capacity.
-
-Flat maps are usually implemented internally as a sorted vector of key/value pairs. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial keys or values. 
-As inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.
-
-To improve insertion performance ETL reference flat maps are implemented as vectors of pointers to key/value pairs, sorted by key value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.
-
-The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat map implementation does not have this overhead.
-
diff --git a/docs/raw/containers/reference_flat_set.txt b/docs/raw/containers/reference_flat_set.txt
deleted file mode 100644
index 08e70283..00000000
--- a/docs/raw/containers/reference_flat_set.txt
+++ /dev/null
@@ -1,216 +0,0 @@
-reference_flat_set
-reference_flat_multiset
-
-A fixed capacity set based on a sorted vector.
-The container stores references to objects, rather than the objects themselves.
-The container is an associative lookup table with O(N) insertion and erase, and O(log N) search.
-This container is best used for tables that are occasionally updated and spend most of their time being searched.
-The interface is most similar to std::set.
-Uses etl::less as the default key comparison method.
-
-etl::reference_flat_set<typename T, const size_t SIZE, TCompare = etl::less>
-
-Inherits from etl::ireference_flat_set<T, TCompare>
-etl::ireference_flat_set may be used as a size independent pointer or reference type for any etl::reference_flat_set instance.
-
-____________________________________________________________________________________________________
-Template deduction guides
-C++17 and above
-
-template <typename... T>
-etl::reference_flat_set(T...)
-
-Example
-etl::reference_flat_setdata{ 0, 1, 2, 3, 4, 5, 6, 7 };
-Defines data as a set of int/int pairs, of length 8, containing the supplied data.
-____________________________________________________________________________________________________
-Make template
-C++11 and above
-template <typename TKey
-          typename... T>
-constexpr auto make_reference_flat_set(T&&... values)
-
-Example
-auto data = etl::make_reference_flat_set<int>(0, 1, 2, 3, 4, 5, 6, 7);
-
-____________________________________________________________________________________________________
-Member types
-
-key_type                T
-value_type              T
-size_type               size_t
-difference_type         ptrdiff_t
-reference               value_type&
-const_reference         const value_type&
-pointer                 value_type*
-const_pointer           const value_type*
-iterator                Random access iterator
-const_iterator          Constant random access iterator
-reverse_iterator        ETL_OR_STD:reverse_iterator<iterator>
-const_reverse_iterator  ETL_OR_STD::reverse_iterator<const_iterator>
-
-____________________________________________________________________________________________________
-Constructor
-etl::flat_set<T, SIZE, TCompare>();
-
-etl::flat_set(const flat_set& other)
-
-template <typename TIterator>
-etl::flat_set<T, SIZE, TCompare>(TIterator begin, TIterator end);
-If the set is full then emits an etl::reference_flat_set_full. If asserts or exceptions are not enabled then undefined behaviour occurs.
-
-____________________________________________________________________________________________________
-Iterators
-iterator begin()
-const_iterator begin() const
-const_iterator cbegin() const
-Returns an iterator to the beginning of the set.
-____________________________________________________________________________________________________
-
-iterator end()
-const_iterator end() const
-const_iterator cend() const
-Returns an iterator to the end of the set.
-____________________________________________________________________________________________________
-
-iterator rbegin()
-const_iterator rbegin() const
-const_iterator crbegin() const
-Returns a reverse iterator to the beginning of the set.
-____________________________________________________________________________________________________
-
-iterator rend()
-const_iterator rend() const
-const_iterator crend() const
-Returns a reverse iterator to the end of the set.
-____________________________________________________________________________________________________
-Capacity
-
-bool empty() const
-Returns true if the size of the set is zero, otherwise false.
-____________________________________________________________________________________________________
-
-bool full() const
-Returns true if the size of the lookup is SIZE, otherwise false.
-____________________________________________________________________________________________________
-
-size_t size() const
-Returns the size of the lookup.
-____________________________________________________________________________________________________
-
-size_t max_size() const
-Returns the maximum possible size of the set.
-____________________________________________________________________________________________________
-
-size_t available() const
-Returns the remaining available capacity in the set.
-____________________________________________________________________________________________________
-Modifiers
-
-flat_set& operator = (const flat_set& rhs)
-Copies the data from another flat set.
-____________________________________________________________________________________________________
-
-ETL_OR_STD::pair<iterator, bool> insert(const value_type& value)
-iterator insert(iterator position, const value_type& value)
-
-template <typename TIterator>
-void insert(TIterator first, TIterator last)
-Inserts values in to the set.
-If the set is full then emits an etl::reference_flat_set_full. If asserts or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-
-size_t erase(key_value_parameter_t key)
-void erase(iterator i_element)
-void erase(iterator first, iterator last)
-Erases values in the set.
-Iterators are not checked for validity.
-
-20.21.0
-template <typename K>
-size_t erase(K&& key)
-Erases values in the map.
-____________________________________________________________________________________________________
-
-void clear();
-Clears the lookup to a size of zero.
-____________________________________________________________________________________________________
-Search
-
-iterator find(key_value_parameter_t key)
-const_iterator find(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-iterator lower_bound(key_value_parameter_t key)
-const_iterator lower_bound(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-iterator upper_bound(key_value_parameter_t key)
-const_iterator upper_bound(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-ETL_OR_STD::pair<iterator, iterator> equal_range(key_value_parameter_t key)
-ETL_OR_STD::pair<const_iterator, const_iterator> equal_range(key_value_parameter_t key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-For comparators that define is_transparent.
-
-template <typename K>
-iterator find(const K& key)
-
-template <typename K>
-const_iterator find(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-iterator lower_bound(const K& key)
-
-template <typename K>
-const_iterator lower_bound(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-iterator upper_bound(const K& key)
-
-template <typename K>
-const_iterator upper_bound(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-C++11 or above
-template <typename K>
-pair<iterator, iterator> equal_range(const K& key)
-
-template <typename K>
-pair<const_iterator, const_iterator> equal_range(const K& key) const
-____________________________________________________________________________________________________
-20.21.0
-bool contains(key_value_parameter_t  key) const
-Check if the container contains the key.
-
-20.21.0
-C++11 or above
-For comparators that define is_transparent.
-template <typename K>
-bool contains(const K& k) const
-Check if the container contains the key.
-____________________________________________________________________________________________________
-Non-member functions
-Lexicographically comparisons
-
-==  true if the contents of the sets are equal, otherwise false.
-!=  true if the contents of the sets are not equal, otherwise false.
-____________________________________________________________________________________________________
-How it works
-
-Reference flat sets are different from the normal version in that the elements are not copied, but linked directly.
-This means that the lifetime of the element inserted must be as great as that of the set that contains it.
-Unlike most other reference containers, the set has a finite capacity.
-
-Flat sets are usually implemented internally as a sorted vector of values. Whilst this makes searching fast, it can have a detrimental effect when items are inserted into a container that stores complex, non-trivial values. 
-As Inserting requires that all of the items above the insert position must be shifted, this can become an expensive operation for larger containers.
-
-To improve insertion performance ETL reference flat sets are implemented as vectors of pointers to values, sorted by value. An insertion will involve a copy of a range of pointers; an operation that can be made very fast.
-
-The downside is that access to an item via an iterator will involve one indirection and the overhead of the container will be one pointer per item. A normal flat set implementation does not have this overhead.
-
-
diff --git a/docs/raw/containers/unordered_map.txt b/docs/raw/containers/unordered_map.txt
deleted file mode 100644
index be4febdb..00000000
--- a/docs/raw/containers/unordered_map.txt
+++ /dev/null
@@ -1,192 +0,0 @@
-unordered_map
-unordered_multimap
-
-A fixed capacity map.
-Uses std::less as the default key comparison method.
-STL equivalent: std::unordered_map / std::unordered_multimap
-
-This page just describes etl::unordered_map.
-
-template <typename TKey, 
-          typename TValue, 
-          size_t   MAX_SIZE, 
-          size_t   MAX_BUCKETS = MAX_SIZE, 
-          typename THash = etl::hash<TKey>, 
-          typename TKeyEqual = etl::equal_to<TKey>>
-class unordered_map
-
-Inherits from  iunordered_map<TKey, TValue, THash, TKeyEqual>
-etl::iunordered_map may be used as a size independent pointer or reference type for any etl::unordered_map instance.
-____________________________________________________________________________________________________
-Template deduction guides
-C++17 and above
-
-template <typename... TPairs>
-etl::unordered_map(TPairs...)
-
-Example
-etl::unordered_map data{ etl::pair{0, 1}, etl::pair{2, 3}, etl::pair{4, 5}, etl::pair{6, 7} };
-Defines data as an map of int/int pairs, of length 4, containing the supplied data.
-____________________________________________________________________________________________________
-Make template
-C++11 and above
-template <typename TKey, 
-          typename TValue, 
-          typename THash       = etl::hash<TKey>, 
-          typename TKeyEqual   = etl::equal_to<TKey>
-          typename... TPairs>
-constexpr auto make_unordered_map(TValues&&... values)
-
-Example
-auto data = etl::make_unordered_map<int, int>(etl::pair{0, 1}, etl::pair{2, 3}, 
-                                              etl::pair{4, 5}, etl::pair{6, 7});
-____________________________________________________________________________________________________
-Member types
-
-value_type              pair<const TKey, T>
-key_type                The type of the key value
-mapped_type             The type of the mapped value
-hasher                  The type used to hash the key
-key_equal               The functor used to compare keys
-reference               A reference to a value_type
-const_reference         A reference to a const value_type
-pointer                 A pointer to a value_type
-const_pointer           A pointer to a const value_type
-size_type               The type used for size information
-iterator                Random access iterator
-const_iterator          Constant random access iterator
-local_iterator          Iterator to a bucket
-local_const_iterator    A const iterator to a bucket
-____________________________________________________________________________________________________
-Constructor
-
-unordered_map()
-Default constructor
-
-unordered_map(const unordered_map& other)
-Copy constructor
-
-template <typename TIterator>
-unordered_map(TIterator begin, TIterator end);
-Construct from a range
-____________________________________________________________________________________________________
-Element access
-
-mapped_type& at(key_parameter_t key)
-const mapped_type& at(key_parameter_t key) const
-Returns a reference or const reference to the indexed element. 
-Emits an etl::map_out_of_range if the key is not in the table. If assert or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-mapped_type& operator[](key_parameter_t key)
-Returns a reference to the indexed element.
-If the key does not exist then one is created using the default constructor. If the map is full then emits an etl::map_full. If asserts or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-iterator find(key_parameter_t key);
-const_iterator find (key_parameter_t key) const;
-Searches the container for an element with a key equivalent to key and returns an iterator to it if found, otherwise it returns an iterator to etl::map::end()
-____________________________________________________________________________________________________
-bool contains(const_key_reference key) const
-Check if the map contains the key.
-
-template <typename K, typename KE = TKeyEqual>
-bool contains(const K& key) const
-Check if the map contains the key.
-Enabled if the comparator is transparent.
-____________________________________________________________________________________________________
-size_type count(key_parameter_t key) const;
-Count elements with a specific key.
-Searches the container for elements with a key equivalent to key and returns the number of matches
-____________________________________________________________________________________________________
-iterator lower_bound(key_parameter_t key);
-const_iterator lower_bound(key_parameter_t key) const;
-Returns the iterator to the lower bound.
-Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
-____________________________________________________________________________________________________
-iterator upper_bound(key_parameter_t key);
-const_iterator upper_bound(key_parameter_t key) const;
-Return the iterator to the upper bound.
-Returns an iterator pointing to the first element in the container whose key is considered to go after key.
-____________________________________________________________________________________________________
-pair<iterator, iterator> equal_range(key_parameter_t key);
-pair<const_iterator, const_iterator> equal_range(key_parameter_t key) const;
-Get the range of equal elements.
-Returns the bounds of a range that includes all the elements in the container which have a key equivalent to key.
-____________________________________________________________________________________________________
-Iterators
-
-iterator begin()
-const_iterator begin() const
-const_iterator cbegin() const
-Returns an iterator to the beginning of the map.
-____________________________________________________________________________________________________
-iterator end()
-const_iterator end() const
-const_iterator cend() const
-Returns an iterator to the end of the map.
-____________________________________________________________________________________________________
-Capacity
-
-bool empty() const
-Returns true if the size of the map is zero, otherwise false.
-____________________________________________________________________________________________________
-bool full() const
-Returns true if the size of the map is SIZE, otherwise false.
-____________________________________________________________________________________________________
-size_t size() const
-Returns the size of the map.
-____________________________________________________________________________________________________
-size_t max_size() const
-Returns the maximum possible size of the map.
-____________________________________________________________________________________________________
-size_t available() const
-Returns the remaining available capacity in the map.
-____________________________________________________________________________________________________
-size_type get_bucket_index(key_parameter_t key) const
-Returns the bucket index for the key.
-____________________________________________________________________________________________________
-size_type bucket_size(key_parameter_t key) const
-Returns the size of the bucket key.
-____________________________________________________________________________________________________
-size_type max_bucket_count() const
-Returns the maximum number of the buckets the container can hold.
-____________________________________________________________________________________________________
-float load_factor() const
-Returns the load factor = size / bucket_count
-____________________________________________________________________________________________________
-hasher hash_function() const
-Returns the function that hashes the keys.
-____________________________________________________________________________________________________
-key_equal key_eq() const
-Returns the function that compares the keys.
-____________________________________________________________________________________________________
-Modifiers
-
-template <typename TIterator>
-void assign(TIterator first, TIterator last)
-Assigns elements from a range.
-Clears the container before assigning.
-____________________________________________________________________________________________________
-pair<iterator, bool> insert(const value_type& key_value_pair)
-iterator insert(const_iterator, const value_type& key_value_pair)
-____________
-template <template TIterator>
-void insert(TIterator first, TIterator last)
-Inserts values in to the map. 
-If the map is full then emits an etl::unordered_map_full error. If asserts or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-size_t erase(key_parameter_t key)
-____________
-iterator erase(const_iterator ielement)
-____________
-iterator erase(const_iterator first, const_iterator last)
-Erases values in the map.
-Iterator are not checked for validity.
-____________________________________________________________________________________________________
-void clear();
-Clears the map to a size of zero.
-____________________________________________________________________________________________________
-Non-member functions
-
-==  true if the contents of the maps are equal, otherwise false.
-!=  true if the contents of the maps are not equal, otherwise false.
-
diff --git a/docs/raw/containers/unordered_set.txt b/docs/raw/containers/unordered_set.txt
deleted file mode 100644
index 4d060d4f..00000000
--- a/docs/raw/containers/unordered_set.txt
+++ /dev/null
@@ -1,181 +0,0 @@
-unordered_set
-unordered_multiset
-
-A fixed capacity set.
-Uses std::less as the default key comparison method.
-STL equivalent: std::unordered_set / std::unordered_multiset
-
-This page just describes etl::unordered_set.
-
-template <typename     TKey, 
-          const size_t MAX_SIZE, 
-          const size_t MAX_BUCKETS = MAX_SIZE, 
-          typename     THash = etl::hash<TKey>, 
-          typename     TKeyEqual = etl::equal_to<TKey>>
-class unordered_set
-
-Inherits from  iunordered_set<TKey, THash, TKeyEqual>
-etl::iunordered_set may be used as a size independent pointer or reference type for any etl::unordered_set instance.
-____________________________________________________________________________________________________
-Template deduction guides
-C++17 and above
-
-template <typename... T>
-etl::unordered_set(T...)
-
-Example
-etl::unordered_set data{ 0, 1, 2, 3, 4, 5, 6, 7 };
-Defines data as a set of int/int pairs, of length 8, containing the supplied data.
-____________________________________________________________________________________________________
-Make template
-C++11 and above
-template <typename TKey
-          typename THash       = etl::hash<TKey>, 
-          typename TKeyEqual   = etl::equal_to<TKey>
-          typename... T>
-constexpr auto make_unordered_set(TValues&&... values)
-
-Example
-auto data = etl::make_unordered_set<int>(0, 1, 2, 3, 4, 5, 6, 7);
-____________________________________________________________________________________________________
-Member types
-
-value_type              pair<const TKey, T>
-key_type                The type of the key value
-hasher                  The type used to hash the key
-key_equal               The functor used to compare keys
-reference               A reference to a value_type
-const_reference         A reference to a const value_type
-pointer                 A pointer to a value_type
-const_pointer           A pointer to a const value_type
-size_type               The type used for size information
-iterator                Random access iterator
-const_iterator          Constant random access iterator
-local_iterator          Iterator to a bucket
-local_const_iterator    A const iterator to a bucket
-____________________________________________________________________________________________________
-Constructor
-
-unordered_set()
-Default constructor
-____________________________________________________________________________________________________
-unordered_set(const unordered_set& other)
-Copy constructor
-____________________________________________________________________________________________________
-template <typename TIterator>
-unordered_set(TIterator begin, TIterator end);
-Construct from a range
-____________________________________________________________________________________________________
-Element access
-
-iterator find(key_parameter_t key);
-const_iterator find (key_parameter_t key) const;
-Searches the container for an element with a key equivalent to key and returns an iterator to it if found, otherwise it returns an iterator to etl::map::end()
-____________________________________________________________________________________________________
-bool contains(const_key_reference key) const
-Check if the map contains the key.
-
-template <typename K, typename KE = TKeyEqual>
-bool contains(const K& key) const
-Check if the map contains the key.
-Enabled if the comparator is transparent.
-____________________________________________________________________________________________________
-size_type count(key_parameter_t key) const;
-Count elements with a specific key.
-Searches the container for elements with a key equivalent to key and returns the number of matches
-____________________________________________________________________________________________________
-iterator lower_bound(key_parameter_t key);
-const_iterator lower_bound(key_parameter_t key) const;
-Returns the iterator to the lower bound.
-Returns an iterator pointing to the first element in the container whose key is not considered to go before key (i.e., either it is equivalent or goes after).
-____________________________________________________________________________________________________
-iterator upper_bound(key_parameter_t key);
-const_iterator upper_bound(key_parameter_t key) const;
-Return the iterator to the upper bound.
-Returns an iterator pointing to the first element in the container whose key is considered to go after key.
-____________________________________________________________________________________________________
-
-pair<iterator, iterator> equal_range(key_parameter_t key);
-pair<const_iterator, const_iterator> equal_range(key_parameter_t key) const;
-Get the range of equal elements.
-Returns the bounds of a range that includes all the elements in the container which have a key equivalent to key.
-____________________________________________________________________________________________________
-Iterators
-
-iterator begin()
-const_iterator begin() const
-const_iterator cbegin() const
-Returns an iterator to the beginning of the map.
-____________________________________________________________________________________________________
-iterator end()
-const_iterator end() const
-const_iterator cend() const
-Returns an iterator to the end of the map.
-____________________________________________________________________________________________________
-Capacity
-
-bool empty() const
-Returns true if the size of the map is zero, otherwise false.
-____________________________________________________________________________________________________
-bool full() const
-Returns true if the size of the map is SIZE, otherwise false.
-____________________________________________________________________________________________________
-size_t size() const
-Returns the size of the map.
-____________________________________________________________________________________________________
-size_t max_size() const
-Returns the maximum possible size of the map.
-____________________________________________________________________________________________________
-size_t available() const
-Returns the remaining available capacity in the map.
-____________________________________________________________________________________________________
-size_type get_bucket_index(key_parameter_t key) const
-Returns the bucket index for the key.
-____________________________________________________________________________________________________
-size_type bucket_size(key_parameter_t key) const
-Returns the size of the bucket key.
-____________________________________________________________________________________________________
-size_type max_bucket_count() const
-Returns the maximum number of the buckets the container can hold.
-____________________________________________________________________________________________________
-float load_factor() const
-Returns the load factor = size / bucket_count
-____________________________________________________________________________________________________
-hasher hash_function() const
-Returns the function that hashes the keys.
-____________________________________________________________________________________________________
-key_equal key_eq() const
-Returns the function that compares the keys.
-____________________________________________________________________________________________________
-Modifiers
-
-template <typename TIterator>
-void assign(TIterator first, TIterator last)
-Assigns elements from a range.
-Clears the container before assigning.
-___________________________________________________________________________________________________
-pair<iterator, bool> insert(const value_type& key_value_pair)
-_______________________________________
-iterator insert(const_iterator, const value_type& key_value_pair)
-_______________________________________
-template <template TIterator>
-void insert(TIterator first, TIterator last)
-Inserts values in to the map. 
-If the set is full then emits an etl::unordered_set_full error. If asserts or exceptions are not enabled then undefined behaviour occurs.
-____________________________________________________________________________________________________
-size_t erase(key_parameter_t key)
-____________
-iterator erase(const_iterator ielement)
-____________
-iterator erase(const_iterator first, const_iterator last)
-Erases values in the set.
-Iterator are not checked for validity.
-____________________________________________________________________________________________________
-void clear();
-Clears the set to a size of zero.
-____________________________________________________________________________________________________
-Non-member functions
-
-==  true if the contents of the sets are equal, otherwise false.
-!=  true if the contents of the sets are not equal, otherwise false.
-
diff --git a/docs/utilities/bit_stream_writer.md b/docs/utilities/bit-stream-writer.md
similarity index 100%
rename from docs/utilities/bit_stream_writer.md
rename to docs/utilities/bit-stream-writer.md
diff --git a/docs/utilities/byte_stream_writer.md b/docs/utilities/byte-stream-writer.md
similarity index 100%
rename from docs/utilities/byte_stream_writer.md
rename to docs/utilities/byte-stream-writer.md