[containers] Index exposition-only iterator-related alias templates.

cplusplus · Jul 5, 2021 · f92eaa0 · f92eaa0
1 parent 4f5af20
commit f92eaa0
Showing 1 changed file with 75 additions and 75 deletions.
diff --git a/source/containers.tex b/source/containers.tex
@@ -3195,7 +3195,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}
@@ -3840,9 +3840,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>;
 }
 \end{codeblock}
 
@@ -4275,9 +4275,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>;
 }
 \end{codeblock}
 
@@ -5084,9 +5084,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>;
 }
 \end{codeblock}
 
@@ -5777,9 +5777,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>;
 }
 \end{codeblock}%
 \indexlibrarymember{vector}{operator==}%
@@ -6386,16 +6386,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}
@@ -6745,10 +6745,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>>>
@@ -6757,8 +6757,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>;
@@ -7267,10 +7267,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>,
@@ -7280,8 +7280,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)
@@ -7568,20 +7568,20 @@
   };
 
   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())
       -> set<Key, Compare, Allocator>;
 
   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>;
@@ -7842,20 +7842,20 @@
   };
 
   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())
       -> multiset<Key, Compare, Allocator>;
 
   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>;
@@ -8306,12 +8306,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>,
@@ -8323,20 +8323,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,
@@ -8877,13 +8877,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>,
@@ -8895,21 +8895,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,
@@ -9242,12 +9242,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>,
@@ -9258,16 +9258,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>
@@ -9567,12 +9567,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>,
@@ -9583,16 +9583,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>