From 5aa98760b0d72229779555a3044632d109c32da3 Mon Sep 17 00:00:00 2001
From: Jens Maurer <Jens.Maurer@gmx.net>
Date: Mon, 14 Dec 2020 19:48:20 +0100
Subject: [PATCH] [containers] Index exposition-only iterator-related alias
 templates.

---
 source/containers.tex | 150 +++++++++++++++++++++---------------------
 1 file changed, 75 insertions(+), 75 deletions(-)

diff --git a/source/containers.tex b/source/containers.tex
index 248bb77551..431c997472 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -3119,7 +3119,7 @@
 
 \begin{codeblock}
 template<class InputIterator>
-  using @\placeholdernc{iter-value-type}@ = typename iterator_traits<InputIterator>::value_type;  // \expos
+  using @\libexposidnc{iter-value-type}@ = typename iterator_traits<InputIterator>::value_type;  // \expos
 \end{codeblock}
 
 \rSec2[array.syn]{Header \tcode{<array>} synopsis}
@@ -3764,9 +3764,9 @@
     void     clear() noexcept;
   };
 
-  template<class InputIterator, class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     deque(InputIterator, InputIterator, Allocator = Allocator())
-      -> deque<@\placeholder{iter-value-type}@<InputIterator>, Allocator>;
+      -> deque<@\exposid{iter-value-type}@<InputIterator>, Allocator>;
 
   // swap
   template<class T, class Allocator>
@@ -4204,9 +4204,9 @@
     void reverse() noexcept;
   };
 
-  template<class InputIterator, class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
-      -> forward_list<@\placeholder{iter-value-type}@<InputIterator>, Allocator>;
+      -> forward_list<@\exposid{iter-value-type}@<InputIterator>, Allocator>;
 
   // swap
   template<class T, class Allocator>
@@ -5001,9 +5001,9 @@
     void reverse() noexcept;
   };
 
-  template<class InputIterator, class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     list(InputIterator, InputIterator, Allocator = Allocator())
-      -> list<@\placeholder{iter-value-type}@<InputIterator>, Allocator>;
+      -> list<@\exposid{iter-value-type}@<InputIterator>, Allocator>;
 
   // swap
   template<class T, class Allocator>
@@ -5694,9 +5694,9 @@
     constexpr void     clear() noexcept;
   };
 
-  template<class InputIterator, class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     vector(InputIterator, InputIterator, Allocator = Allocator())
-      -> vector<@\placeholder{iter-value-type}@<InputIterator>, Allocator>;
+      -> vector<@\exposid{iter-value-type}@<InputIterator>, Allocator>;
 
   // swap
   template<class T, class Allocator>
@@ -6308,16 +6308,16 @@
 The following exposition-only alias templates may appear in deduction guides for associative containers:
 \begin{codeblock}
 template<class InputIterator>
-  using @\placeholder{iter-value-type}@ =
+  using @\libexposid{iter-value-type}@ =
     typename iterator_traits<InputIterator>::value_type;                // \expos
 template<class InputIterator>
-  using @\placeholder{iter-key-type}@ = remove_const_t<
+  using @\libexposid{iter-key-type}@ = remove_const_t<
     typename iterator_traits<InputIterator>::value_type::first_type>;   // \expos
 template<class InputIterator>
-  using @\placeholder{iter-mapped-type}@ =
+  using @\libexposid{iter-mapped-type}@ =
     typename iterator_traits<InputIterator>::value_type::second_type;   // \expos
 template<class InputIterator>
-  using @\placeholder{iter-to-alloc-type}@ = pair<
+  using @\libexposid{iter-to-alloc-type}@ = pair<
     add_const_t<typename iterator_traits<InputIterator>::value_type::first_type>,
     typename iterator_traits<InputIterator>::value_type::second_type>;  // \expos
 \end{codeblock}
@@ -6667,10 +6667,10 @@
       pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
 
-  template<class InputIterator, class Compare = less<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-to-alloc-type}@<InputIterator>>>
+  template<class InputIterator, class Compare = less<@\exposid{iter-key-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-to-alloc-type}@<InputIterator>>>
     map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
-      -> map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>, Compare, Allocator>;
+      -> map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Compare, Allocator>;
 
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
@@ -6679,8 +6679,8 @@
 
   template<class InputIterator, class Allocator>
     map(InputIterator, InputIterator, Allocator)
-      -> map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-             less<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+             less<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class T, class Allocator>
     map(initializer_list<pair<Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>;
@@ -7195,10 +7195,10 @@
       pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
 
-  template<class InputIterator, class Compare = less<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-to-alloc-type}@<InputIterator>>>
+  template<class InputIterator, class Compare = less<@\exposid{iter-key-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-to-alloc-type}@<InputIterator>>>
     multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
-      -> multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
+      -> multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
                   Compare, Allocator>;
 
   template<class Key, class T, class Compare = less<Key>,
@@ -7208,8 +7208,8 @@
 
   template<class InputIterator, class Allocator>
     multimap(InputIterator, InputIterator, Allocator)
-      -> multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-                  less<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+                  less<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class T, class Allocator>
     multimap(initializer_list<pair<Key, T>>, Allocator)
@@ -7502,11 +7502,11 @@
   };
 
   template<class InputIterator,
-           class Compare = less<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+           class Compare = less<@\exposid{iter-value-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     set(InputIterator, InputIterator,
         Compare = Compare(), Allocator = Allocator())
-      -> set<@\placeholder{iter-value-type}@<InputIterator>, Compare, Allocator>;
+      -> set<@\exposid{iter-value-type}@<InputIterator>, Compare, Allocator>;
 
   template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
     set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
@@ -7514,8 +7514,8 @@
 
   template<class InputIterator, class Allocator>
     set(InputIterator, InputIterator, Allocator)
-      -> set<@\placeholder{iter-value-type}@<InputIterator>,
-             less<@\placeholder{iter-value-type}@<InputIterator>>, Allocator>;
+      -> set<@\exposid{iter-value-type}@<InputIterator>,
+             less<@\exposid{iter-value-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class Allocator>
     set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>;
@@ -7782,11 +7782,11 @@
   };
 
   template<class InputIterator,
-           class Compare = less<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+           class Compare = less<@\exposid{iter-value-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     multiset(InputIterator, InputIterator,
              Compare = Compare(), Allocator = Allocator())
-      -> multiset<@\placeholder{iter-value-type}@<InputIterator>, Compare, Allocator>;
+      -> multiset<@\exposid{iter-value-type}@<InputIterator>, Compare, Allocator>;
 
   template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
     multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
@@ -7794,8 +7794,8 @@
 
   template<class InputIterator, class Allocator>
     multiset(InputIterator, InputIterator, Allocator)
-      -> multiset<@\placeholder{iter-value-type}@<InputIterator>,
-                  less<@\placeholder{iter-value-type}@<InputIterator>>, Allocator>;
+      -> multiset<@\exposid{iter-value-type}@<InputIterator>,
+                  less<@\exposid{iter-value-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class Allocator>
     multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>;
@@ -8252,12 +8252,12 @@
   };
 
   template<class InputIterator,
-           class Hash = hash<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Pred = equal_to<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-to-alloc-type}@<InputIterator>>>
+           class Hash = hash<@\exposid{iter-key-type}@<InputIterator>>,
+           class Pred = equal_to<@\exposid{iter-key-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-to-alloc-type}@<InputIterator>>>
     unordered_map(InputIterator, InputIterator, typename @\seebelow@::size_type = @\seebelow@,
                   Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      -> unordered_map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>, Hash, Pred,
+      -> unordered_map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Hash, Pred,
                        Allocator>;
 
   template<class Key, class T, class Hash = hash<Key>,
@@ -8269,20 +8269,20 @@
 
   template<class InputIterator, class Allocator>
     unordered_map(InputIterator, InputIterator, typename @\seebelow@::size_type, Allocator)
-      -> unordered_map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-                       hash<@\placeholder{iter-key-type}@<InputIterator>>,
-                       equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+                       hash<@\exposid{iter-key-type}@<InputIterator>>,
+                       equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class InputIterator, class Allocator>
     unordered_map(InputIterator, InputIterator, Allocator)
-      -> unordered_map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-                       hash<@\placeholder{iter-key-type}@<InputIterator>>,
-                       equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+                       hash<@\exposid{iter-key-type}@<InputIterator>>,
+                       equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class InputIterator, class Hash, class Allocator>
     unordered_map(InputIterator, InputIterator, typename @\seebelow@::size_type, Hash, Allocator)
-      -> unordered_map<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>, Hash,
-                       equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Hash,
+                       equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class T, class Allocator>
     unordered_map(initializer_list<pair<Key, T>>, typename @\seebelow@::size_type,
@@ -8829,13 +8829,13 @@
   };
 
   template<class InputIterator,
-           class Hash = hash<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Pred = equal_to<@\placeholder{iter-key-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-to-alloc-type}@<InputIterator>>>
+           class Hash = hash<@\exposid{iter-key-type}@<InputIterator>>,
+           class Pred = equal_to<@\exposid{iter-key-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-to-alloc-type}@<InputIterator>>>
     unordered_multimap(InputIterator, InputIterator,
                        typename @\seebelow@::size_type = @\seebelow@,
                        Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      -> unordered_multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
+      -> unordered_multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
                             Hash, Pred, Allocator>;
 
   template<class Key, class T, class Hash = hash<Key>,
@@ -8847,21 +8847,21 @@
 
   template<class InputIterator, class Allocator>
     unordered_multimap(InputIterator, InputIterator, typename @\seebelow@::size_type, Allocator)
-      -> unordered_multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-                            hash<@\placeholder{iter-key-type}@<InputIterator>>,
-                            equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+                            hash<@\exposid{iter-key-type}@<InputIterator>>,
+                            equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class InputIterator, class Allocator>
     unordered_multimap(InputIterator, InputIterator, Allocator)
-      -> unordered_multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>,
-                            hash<@\placeholder{iter-key-type}@<InputIterator>>,
-                            equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>,
+                            hash<@\exposid{iter-key-type}@<InputIterator>>,
+                            equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class InputIterator, class Hash, class Allocator>
     unordered_multimap(InputIterator, InputIterator, typename @\seebelow@::size_type, Hash,
                        Allocator)
-      -> unordered_multimap<@\placeholder{iter-key-type}@<InputIterator>, @\placeholder{iter-mapped-type}@<InputIterator>, Hash,
-                            equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
+      -> unordered_multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Hash,
+                            equal_to<@\exposid{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<class Key, class T, class Allocator>
     unordered_multimap(initializer_list<pair<Key, T>>, typename @\seebelow@::size_type,
@@ -9200,12 +9200,12 @@
   };
 
   template<class InputIterator,
-           class Hash = hash<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Pred = equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+           class Hash = hash<@\exposid{iter-value-type}@<InputIterator>>,
+           class Pred = equal_to<@\exposid{iter-value-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     unordered_set(InputIterator, InputIterator, typename @\seebelow@::size_type = @\seebelow@,
                   Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      -> unordered_set<@\placeholder{iter-value-type}@<InputIterator>,
+      -> unordered_set<@\exposid{iter-value-type}@<InputIterator>,
                        Hash, Pred, Allocator>;
 
   template<class T, class Hash = hash<T>,
@@ -9216,16 +9216,16 @@
 
   template<class InputIterator, class Allocator>
     unordered_set(InputIterator, InputIterator, typename @\seebelow@::size_type, Allocator)
-      -> unordered_set<@\placeholder{iter-value-type}@<InputIterator>,
-                       hash<@\placeholder{iter-value-type}@<InputIterator>>,
-                       equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
+      -> unordered_set<@\exposid{iter-value-type}@<InputIterator>,
+                       hash<@\exposid{iter-value-type}@<InputIterator>>,
+                       equal_to<@\exposid{iter-value-type}@<InputIterator>>,
                        Allocator>;
 
   template<class InputIterator, class Hash, class Allocator>
     unordered_set(InputIterator, InputIterator, typename @\seebelow@::size_type,
                   Hash, Allocator)
-      -> unordered_set<@\placeholder{iter-value-type}@<InputIterator>, Hash,
-                       equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
+      -> unordered_set<@\exposid{iter-value-type}@<InputIterator>, Hash,
+                       equal_to<@\exposid{iter-value-type}@<InputIterator>>,
                        Allocator>;
 
   template<class T, class Allocator>
@@ -9531,12 +9531,12 @@
   };
 
   template<class InputIterator,
-           class Hash = hash<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Pred = equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
-           class Allocator = allocator<@\placeholder{iter-value-type}@<InputIterator>>>
+           class Hash = hash<@\exposid{iter-value-type}@<InputIterator>>,
+           class Pred = equal_to<@\exposid{iter-value-type}@<InputIterator>>,
+           class Allocator = allocator<@\exposid{iter-value-type}@<InputIterator>>>
     unordered_multiset(InputIterator, InputIterator, @\seebelow@::size_type = @\seebelow@,
                        Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      -> unordered_multiset<@\placeholder{iter-value-type}@<InputIterator>,
+      -> unordered_multiset<@\exposid{iter-value-type}@<InputIterator>,
                             Hash, Pred, Allocator>;
 
   template<class T, class Hash = hash<T>,
@@ -9547,16 +9547,16 @@
 
   template<class InputIterator, class Allocator>
     unordered_multiset(InputIterator, InputIterator, typename @\seebelow@::size_type, Allocator)
-      -> unordered_multiset<@\placeholder{iter-value-type}@<InputIterator>,
-                            hash<@\placeholder{iter-value-type}@<InputIterator>>,
-                            equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
+      -> unordered_multiset<@\exposid{iter-value-type}@<InputIterator>,
+                            hash<@\exposid{iter-value-type}@<InputIterator>>,
+                            equal_to<@\exposid{iter-value-type}@<InputIterator>>,
                             Allocator>;
 
   template<class InputIterator, class Hash, class Allocator>
     unordered_multiset(InputIterator, InputIterator, typename @\seebelow@::size_type,
                        Hash, Allocator)
-      -> unordered_multiset<@\placeholder{iter-value-type}@<InputIterator>, Hash,
-                            equal_to<@\placeholder{iter-value-type}@<InputIterator>>,
+      -> unordered_multiset<@\exposid{iter-value-type}@<InputIterator>, Hash,
+                            equal_to<@\exposid{iter-value-type}@<InputIterator>>,
                             Allocator>;
 
   template<class T, class Allocator>