[utilities] Consistently index member typedefs in the utilites header

Audited the file `utilities.tex` for indexing of member typedefs.  Several
idioms were in use, and not all typedef-names were indexed.  Adopted what
seemed to be the preferred approach of using the `@\libmember{}@` style of
definition within the class definition itself, so that omissions become
obvious if more typedef-names are added in the future.

Please provide feedback on whether indexing the explicit template
specialization for `<void>` types is the correct approach. It pulls
out the name that is not present for the primary template, and then
the ranges library adds some non-template classes with the same name.

Author: AlisdairM

source/utilities.tex

@@ -122,14 +122,14 @@
     requires requires { typename pair<common_reference_t<TQual<T1>, UQual<U1>>,
                                       common_reference_t<TQual<T2>, UQual<U2>>>; }
   struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual> {
-    using type = pair<common_reference_t<TQual<T1>, UQual<U1>>,
+    using @\libmember{type}{basic_common_reference}@ = pair<common_reference_t<TQual<T1>, UQual<U1>>,
                       common_reference_t<TQual<T2>, UQual<U2>>>;
   };
 
   template<class T1, class T2, class U1, class U2>
     requires requires { typename pair<common_type_t<T1, U1>, common_type_t<T2, U2>>; }
   struct common_type<pair<T1, T2>, pair<U1, U2>> {
-    using type = pair<common_type_t<T1, U1>, common_type_t<T2, U2>>;
+    using @\libmember{type}{common_type}@ = pair<common_type_t<T1, U1>, common_type_t<T2, U2>>;
   };
 
   // \ref{pairs.spec}, pair specialized algorithms
@@ -725,8 +725,8 @@
 namespace std {
   template<class T1, class T2>
   struct pair {
-    using first_type  = T1;
-    using second_type = T2;
+    using @\libmember{first_type}{pair}@  = T1;
+    using @\libmember{second_type}{pair}@ = T2;
 
     T1 first;
     T2 second;
@@ -1372,7 +1372,7 @@
 \begin{itemdecl}
 template<size_t I, class T1, class T2>
   struct tuple_element<I, pair<T1, T2>> {
-    using type = @\seebelow@ ;
+    using @\libmember{type}{tuple_element}@ = @\seebelow@ ;
   };
 \end{itemdecl}
 \begin{itemdescr}
@@ -2758,7 +2758,7 @@
 \begin{itemdecl}
 template<size_t I, class... Types>
   struct tuple_element<I, tuple<Types...>> {
-    using type = TI;
+    using @\libmember{type}{tuple_element}@ = TI;
   };
 \end{itemdecl}
 
@@ -3035,7 +3035,7 @@
 template<@\exposconcept{tuple-like}@ TTuple, @\exposconcept{tuple-like}@ UTuple,
          template<class> class TQual, template<class> class UQual>
 struct basic_common_reference<TTuple, UTuple, TQual, UQual> {
-  using type = @\seebelow@;
+  using @\libmember{type}{basic_common_reference}@ = @\seebelow@;
 };
 \end{itemdecl}
 
@@ -3064,7 +3064,7 @@
 \begin{itemdecl}
 template<@\exposconcept{tuple-like}@ TTuple, @\exposconcept{tuple-like}@ UTuple>
 struct common_type<TTuple, UTuple> {
-  using type = @\seebelow@;
+  using @\libmember{type}{common_type}@ = @\seebelow@;
 };
 \end{itemdecl}
 
@@ -3256,9 +3256,9 @@
   template<class T>
   class optional {
   public:
-    using value_type     = T;
-    using iterator       = @\impdefnc@;              // see~\ref{optional.iterators}
-    using const_iterator = @\impdefnc@;              // see~\ref{optional.iterators}
+    using @\libmember{value_type}{optional}@     = T;
+    using @\libmember{iterator}{optional}@       = @\impdefnc@;              // see~\ref{optional.iterators}
+    using @\libmember{const_iterator}{optional}@ = @\impdefnc@;              // see~\ref{optional.iterators}
 
     // \ref{optional.ctor}, constructors
     constexpr optional() noexcept;
@@ -4023,8 +4023,8 @@
 \indexlibrarymember{iterator}{optional}%
 \indexlibrarymember{const_iterator}{optional}%
 \begin{itemdecl}
-using iterator       = @\impdef@;
-using const_iterator = @\impdef@;
+using @\libmember{iterator}{optional}@       = @\impdef@;
+using @\libmember{const_iterator}{optional}@ = @\impdef@;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -11074,7 +11074,7 @@
   template<class T> class reference_wrapper {
   public:
     // types
-    using type = T;
+    using @\libmember{type}{reference_wrapper}@ = T;
 
     // \ref{refwrap.const}, constructors
     template<class U>
@@ -11394,14 +11394,14 @@
     requires (@\exposconcept{ref-wrap-common-reference-exists-with}@<R, T, RQual<R>, TQual<T>> &&
               !@\exposconcept{ref-wrap-common-reference-exists-with}@<T, R, TQual<T>, RQual<R>>)
   struct basic_common_reference<R, T, RQual, TQual> {
-    using type = common_reference_t<typename R::type&, TQual<T>>;
+    using @\libmember{type}{basic_common_reference}@ = common_reference_t<typename R::type&, TQual<T>>;
   };
 
   template<class T, class R, template<class> class TQual, template<class> class RQual>
     requires (@\exposconcept{ref-wrap-common-reference-exists-with}@<R, T, RQual<R>, TQual<T>> &&
               !@\exposconcept{ref-wrap-common-reference-exists-with}@<T, R, TQual<T>, RQual<R>>)
   struct basic_common_reference<T, R, TQual, RQual> {
-    using type = common_reference_t<typename R::type&, TQual<T>>;
+    using @\libmember{type}{basic_common_reference}@ = common_reference_t<typename R::type&, TQual<T>>;
   };
 }
 \end{codeblock}
@@ -11440,7 +11440,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) + std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{plus<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11482,7 +11482,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) - std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{minus<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11524,7 +11524,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) * std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{multiplies<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11566,7 +11566,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) / std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{divides<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11608,7 +11608,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) % std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{modulus<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11650,7 +11650,7 @@
   template<class T> constexpr auto operator()(T&& t) const
     -> decltype(-std::forward<T>(t));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{negate<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11718,7 +11718,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) == std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{equal_to<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11760,7 +11760,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) != std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{not_equal_to<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11802,7 +11802,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) > std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{greater<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11844,7 +11844,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) < std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{less<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11886,7 +11886,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) >= std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{greater_equal<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11928,7 +11928,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) <= std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{less_equal<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -11953,7 +11953,7 @@
     template<class T, class U>
       constexpr auto operator()(T&& t, U&& u) const;
 
-    using is_transparent = @\unspec@;
+    using @\libmember{is_transparent}{compare_three_way}@ = @\unspec@;
   };
 }
 \end{codeblock}
@@ -12002,7 +12002,7 @@
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{equal_to}@ = @\unspecnc@;
 };
 \end{codeblock}
 
@@ -12046,7 +12046,7 @@
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{not_equal_to}@ = @\unspecnc@;
 };
 \end{codeblock}
 
@@ -12074,7 +12074,7 @@
   template<class T, class U>
   constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{greater}@ = @\unspecnc@;
 };
 \end{codeblock}
 
@@ -12102,7 +12102,7 @@
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{less}@ = @\unspecnc@;
 };
 \end{codeblock}
 
@@ -12153,7 +12153,7 @@
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{greater_equal}@ = @\unspecnc@;
 };
 \end{codeblock}
 
@@ -12181,7 +12181,7 @@
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
 
-  using is_transparent = @\unspecnc@;
+  using @\libmember{is_transparent}{less_equal}@ = @\unspecnc@;
 };
 \end{itemdecl}
 
@@ -12237,7 +12237,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) && std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{logical_and<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12279,7 +12279,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) || std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{logical_or<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12321,7 +12321,7 @@
   template<class T> constexpr auto operator()(T&& t) const
     -> decltype(!std::forward<T>(t));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{logical_not<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12372,7 +12372,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) & std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{bit_and<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12414,7 +12414,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) | std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{bit_or<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12456,7 +12456,7 @@
   template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) ^ std::forward<U>(u));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{bit_xor<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12497,7 +12497,7 @@
   template<class T> constexpr auto operator()(T&& t) const
     -> decltype(~std::forward<T>(t));
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{bit_not<>}@ = @\unspec@;
 };
 \end{itemdecl}
 
@@ -12522,7 +12522,7 @@
   template<class T>
     constexpr T&& operator()(T&& t) const noexcept;
 
-  using is_transparent = @\unspec@;
+  using @\libmember{is_transparent}{identity}@ = @\unspec@;
 };
 
 template<class T>
@@ -13076,7 +13076,7 @@
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
-    using result_type = R;
+    using @\libmember{result_type}{function}@ = R;
 
     // \ref{func.wrap.func.con}, construct/copy/destroy
     function() noexcept;
@@ -13547,7 +13547,7 @@
   template<class R, class... ArgTypes>
   class move_only_function<R(ArgTypes...) @\cv{}@ @\placeholder{ref}@ noexcept(@\placeholder{noex}@)> {
   public:
-    using result_type = R;
+    using @\libmember{result_type}{move_only_function}@ = R;
 
     // \ref{func.wrap.move.ctor}, constructors, assignment, and destructor
     move_only_function() noexcept;
@@ -13940,7 +13940,7 @@
   template<class R, class... ArgTypes>
   class copyable_function<R(ArgTypes...) @\cv{}@ @\placeholder{ref}@ noexcept(@\placeholder{noex}@)> {
   public:
-    using result_type = R;
+    using @\libmember{result_type}{copyable_function}@ = R;
 
     // \ref{func.wrap.copy.ctor}, constructors, assignments, and destructors
     copyable_function() noexcept;