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

cplusplus · Jan 19, 2022 · cc1097c · cc1097c
1 parent 705e48b
commit cc1097c
Showing 1 changed file with 75 additions and 75 deletions.
diff --git a/source/containers.tex b/source/containers.tex
@@ -3355,7 +3355,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}
@@ -4000,9 +4000,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}
 
@@ -4435,9 +4435,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}
 
@@ -5244,9 +5244,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}
 
@@ -5937,9 +5937,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==}%
@@ -6547,16 +6547,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}
@@ -6908,10 +6908,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>>>
@@ -6920,8 +6920,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>;
@@ -7432,10 +7432,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>,
@@ -7445,8 +7445,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)
@@ -7735,20 +7735,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>;
@@ -8011,20 +8011,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>;
@@ -8477,12 +8477,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>,
@@ -8494,20 +8494,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,
@@ -9050,13 +9050,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>,
@@ -9068,21 +9068,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,
@@ -9417,12 +9417,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>,
@@ -9433,16 +9433,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>
@@ -9744,12 +9744,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>,
@@ -9760,16 +9760,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>