[meta.type.synop] Whitespace harmonization

Use our usual style for line breaking long declarations, compress unnecessary linebreaks, and fix comment columns.

Author: tkoeppe

source/utilities.tex

@@ -15179,8 +15179,7 @@
     using add_pointer_t    = typename add_pointer<T>::type;
 
   // \ref{meta.trans.other}, other transformations
-  template <size_t Len,
-            size_t Align = @\textit{default-alignment}@> // see \ref{meta.trans.other}
+  template <size_t Len, size_t Align = @\textit{default-alignment}@> // see \ref{meta.trans.other}
     struct aligned_storage;
   template <size_t Len, class... Types> struct aligned_union;
   template <class T> struct decay;
@@ -15190,8 +15189,7 @@
   template <class T> struct underlying_type;
   template <class Fn, class... ArgTypes> struct invoke_result;
 
-  template <size_t Len,
-            size_t Align = @\textit{default-alignment}@> // see \ref{meta.trans.other}
+  template <size_t Len, size_t Align = @\textit{default-alignment}@> // see \ref{meta.trans.other}
     using aligned_storage_t = typename aligned_storage<Len, Align>::type;
   template <size_t Len, class... Types>
     using aligned_union_t   = typename aligned_union<Len, Types...>::type;
@@ -15223,167 +15221,182 @@
   };
 
   // \ref{meta.unary.cat}, primary type categories
-  template <class T> inline constexpr bool is_void_v
-    = is_void<T>::value;
-  template <class T> inline constexpr bool is_null_pointer_v
-    = is_null_pointer<T>::value;
-  template <class T> inline constexpr bool is_integral_v
-    = is_integral<T>::value;
-  template <class T> inline constexpr bool is_floating_point_v
-    = is_floating_point<T>::value;
-  template <class T> inline constexpr bool is_array_v
-    = is_array<T>::value;
-  template <class T> inline constexpr bool is_pointer_v
-    = is_pointer<T>::value;
-  template <class T> inline constexpr bool is_lvalue_reference_v
-    = is_lvalue_reference<T>::value;
-  template <class T> inline constexpr bool is_rvalue_reference_v
-    = is_rvalue_reference<T>::value;
-  template <class T> inline constexpr bool is_member_object_pointer_v
-    = is_member_object_pointer<T>::value;
-  template <class T> inline constexpr bool is_member_function_pointer_v
-    = is_member_function_pointer<T>::value;
-  template <class T> inline constexpr bool is_enum_v
-    = is_enum<T>::value;
-  template <class T> inline constexpr bool is_union_v
-    = is_union<T>::value;
-  template <class T> inline constexpr bool is_class_v
-    = is_class<T>::value;
-  template <class T> inline constexpr bool is_function_v
-    = is_function<T>::value;
+  template <class T>
+    inline constexpr bool is_void_v = is_void<T>::value;
+  template <class T>
+    inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
+  template <class T>
+    inline constexpr bool is_integral_v = is_integral<T>::value;
+  template <class T>
+    inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+  template <class T>
+    inline constexpr bool is_array_v = is_array<T>::value;
+  template <class T>
+    inline constexpr bool is_pointer_v = is_pointer<T>::value;
+  template <class T>
+    inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
+  template <class T>
+    inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
+  template <class T>
+    inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
+  template <class T>
+    inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
+  template <class T>
+    inline constexpr bool is_enum_v = is_enum<T>::value;
+  template <class T>
+    inline constexpr bool is_union_v = is_union<T>::value;
+  template <class T>
+    inline constexpr bool is_class_v = is_class<T>::value;
+  template <class T>
+    inline constexpr bool is_function_v = is_function<T>::value;
 
   // \ref{meta.unary.comp}, composite type categories
-  template <class T> inline constexpr bool is_reference_v
-    = is_reference<T>::value;
-  template <class T> inline constexpr bool is_arithmetic_v
-    = is_arithmetic<T>::value;
-  template <class T> inline constexpr bool is_fundamental_v
-    = is_fundamental<T>::value;
-  template <class T> inline constexpr bool is_object_v
-    = is_object<T>::value;
-  template <class T> inline constexpr bool is_scalar_v
-    = is_scalar<T>::value;
-  template <class T> inline constexpr bool is_compound_v
-    = is_compound<T>::value;
-  template <class T> inline constexpr bool is_member_pointer_v
-    = is_member_pointer<T>::value;
+  template <class T>
+    inline constexpr bool is_reference_v = is_reference<T>::value;
+  template <class T>
+    inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+  template <class T>
+    inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
+  template <class T>
+    inline constexpr bool is_object_v = is_object<T>::value;
+  template <class T>
+    inline constexpr bool is_scalar_v = is_scalar<T>::value;
+  template <class T>
+    inline constexpr bool is_compound_v = is_compound<T>::value;
+  template <class T>
+    inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
 
   // \ref{meta.unary.prop}, type properties
-  template <class T> inline constexpr bool is_const_v
-    = is_const<T>::value;
-  template <class T> inline constexpr bool is_volatile_v
-    = is_volatile<T>::value;
-  template <class T> inline constexpr bool is_trivial_v
-    = is_trivial<T>::value;
-  template <class T> inline constexpr bool is_trivially_copyable_v
-    = is_trivially_copyable<T>::value;
-  template <class T> inline constexpr bool is_standard_layout_v
-    = is_standard_layout<T>::value;
-  template <class T> inline constexpr bool is_pod_v
-    = is_pod<T>::value;
-  template <class T> inline constexpr bool is_empty_v
-    = is_empty<T>::value;
-  template <class T> inline constexpr bool is_polymorphic_v
-    = is_polymorphic<T>::value;
-  template <class T> inline constexpr bool is_abstract_v
-    = is_abstract<T>::value;
-  template <class T> inline constexpr bool is_final_v
-    = is_final<T>::value;
-  template <class T> inline constexpr bool is_aggregate_v
-    = is_aggregate<T>::value;
-  template <class T> inline constexpr bool is_signed_v
-    = is_signed<T>::value;
-  template <class T> inline constexpr bool is_unsigned_v
-    = is_unsigned<T>::value;
-  template <class T, class... Args> inline constexpr bool is_constructible_v
-    = is_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_default_constructible_v
-    = is_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_copy_constructible_v
-    = is_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_move_constructible_v
-    = is_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_assignable_v
-    = is_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_copy_assignable_v
-    = is_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_move_assignable_v
-    = is_move_assignable<T>::value;
-  template <class T, class U> inline constexpr bool is_swappable_with_v
-    = is_swappable_with<T, U>::value;
-  template <class T> inline constexpr bool is_swappable_v
-    = is_swappable<T>::value;
-  template <class T> inline constexpr bool is_destructible_v
-    = is_destructible<T>::value;
-  template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
-    = is_trivially_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_trivially_default_constructible_v
-    = is_trivially_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_trivially_copy_constructible_v
-    = is_trivially_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_trivially_move_constructible_v
-    = is_trivially_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_trivially_assignable_v
-    = is_trivially_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_trivially_copy_assignable_v
-    = is_trivially_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_trivially_move_assignable_v
-    = is_trivially_move_assignable<T>::value;
-  template <class T> inline constexpr bool is_trivially_destructible_v
-    = is_trivially_destructible<T>::value;
-  template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
-    = is_nothrow_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_nothrow_default_constructible_v
-    = is_nothrow_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_nothrow_copy_constructible_v
+  template <class T>
+    inline constexpr bool is_const_v = is_const<T>::value;
+  template <class T>
+    inline constexpr bool is_volatile_v = is_volatile<T>::value;
+  template <class T>
+    inline constexpr bool is_trivial_v = is_trivial<T>::value;
+  template <class T>
+    inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+  template <class T>
+    inline constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
+  template <class T>
+    inline constexpr bool is_pod_v = is_pod<T>::value;
+  template <class T>
+    inline constexpr bool is_empty_v = is_empty<T>::value;
+  template <class T>
+    inline constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
+  template <class T>
+    inline constexpr bool is_abstract_v = is_abstract<T>::value;
+  template <class T>
+    inline constexpr bool is_final_v = is_final<T>::value;
+  template <class T>
+    inline constexpr bool is_aggregate_v = is_aggregate<T>::value;
+  template <class T>
+    inline constexpr bool is_signed_v = is_signed<T>::value;
+  template <class T>
+    inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
+  template <class T, class... Args>
+    inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
+  template <class T>
+    inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
+  template <class T>
+    inline constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
+  template <class T>
+    inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
+  template <class T, class U>
+    inline constexpr bool is_assignable_v = is_assignable<T, U>::value;
+  template <class T>
+    inline constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
+  template <class T>
+    inline constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
+  template <class T, class U>
+    inline constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
+  template <class T>
+    inline constexpr bool is_swappable_v = is_swappable<T>::value;
+  template <class T>
+    inline constexpr bool is_destructible_v = is_destructible<T>::value;
+  template <class T, class... Args>
+    inline constexpr bool is_trivially_constructible_v
+      = is_trivially_constructible<T, Args...>::value;
+  template <class T>
+    inline constexpr bool is_trivially_default_constructible_v
+      = is_trivially_default_constructible<T>::value;
+  template <class T>
+    inline constexpr bool is_trivially_copy_constructible_v
+      = is_trivially_copy_constructible<T>::value;
+  template <class T>
+    inline constexpr bool is_trivially_move_constructible_v
+      = is_trivially_move_constructible<T>::value;
+  template <class T, class U>
+    inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
+  template <class T>
+    inline constexpr bool is_trivially_copy_assignable_v
+      = is_trivially_copy_assignable<T>::value;
+  template <class T>
+    inline constexpr bool is_trivially_move_assignable_v
+      = is_trivially_move_assignable<T>::value;
+  template <class T>
+    inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
+  template <class T, class... Args>
+    inline constexpr bool is_nothrow_constructible_v
+      = is_nothrow_constructible<T, Args...>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_default_constructible_v
+      = is_nothrow_default_constructible<T>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_copy_constructible_v
     = is_nothrow_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_nothrow_move_constructible_v
-    = is_nothrow_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_nothrow_assignable_v
-    = is_nothrow_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_nothrow_copy_assignable_v
-    = is_nothrow_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_nothrow_move_assignable_v
-    = is_nothrow_move_assignable<T>::value;
-  template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
-    = is_nothrow_swappable_with<T, U>::value;
-  template <class T> inline constexpr bool is_nothrow_swappable_v
-    = is_nothrow_swappable<T>::value;
-  template <class T> inline constexpr bool is_nothrow_destructible_v
-    = is_nothrow_destructible<T>::value;
-  template <class T> inline constexpr bool has_virtual_destructor_v
-    = has_virtual_destructor<T>::value;
-  template <class T> inline constexpr bool has_unique_object_representations_v
-    = has_unique_object_representations<T>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_move_constructible_v
+      = is_nothrow_move_constructible<T>::value;
+  template <class T, class U>
+    inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
+  template <class T, class U>
+    inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
+  template <class T>
+    inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
+  template <class T>
+    inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
+  template <class T>
+    inline constexpr bool has_unique_object_representations_v
+      = has_unique_object_representations<T>::value;
 
   // \ref{meta.unary.prop.query}, type property queries
-  template <class T> inline constexpr size_t alignment_of_v
-    = alignment_of<T>::value;
-  template <class T> inline constexpr size_t rank_v
-    = rank<T>::value;
-  template <class T, unsigned I = 0> inline constexpr size_t extent_v
-    = extent<T, I>::value;
+  template <class T>
+    inline constexpr size_t alignment_of_v = alignment_of<T>::value;
+  template <class T>
+    inline constexpr size_t rank_v = rank<T>::value;
+  template <class T, unsigned I = 0>
+    inline constexpr size_t extent_v = extent<T, I>::value;
 
   // \ref{meta.rel}, type relations
-  template <class T, class U> inline constexpr bool is_same_v
-    = is_same<T, U>::value;
-  template <class Base, class Derived> inline constexpr bool is_base_of_v
-    = is_base_of<Base, Derived>::value;
-  template <class From, class To> inline constexpr bool is_convertible_v
-    = is_convertible<From, To>::value;
-  template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v
-    = is_invocable<Fn, ArgTypes...>::value;
-  template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v
-    = is_invocable_r<R, Fn, ArgTypes...>::value;
-  template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v
-    = is_nothrow_invocable<Fn, ArgTypes...>::value;
-  template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v
-    = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+  template <class T, class U>
+    inline constexpr bool is_same_v = is_same<T, U>::value;
+  template <class Base, class Derived>
+    inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
+  template <class From, class To>
+    inline constexpr bool is_convertible_v = is_convertible<From, To>::value;
+  template <class Fn, class... ArgTypes>
+    inline constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
+  template <class R, class Fn, class... ArgTypes>
+    inline constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
+  template <class Fn, class... ArgTypes>
+    inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
+  template <class R, class Fn, class... ArgTypes>
+    inline constexpr bool is_nothrow_invocable_r_v
+      = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
 
   // \ref{meta.logical}, logical operator traits
-  template<class... B> inline constexpr bool conjunction_v = conjunction<B...>::value;
-  template<class... B> inline constexpr bool disjunction_v = disjunction<B...>::value;
-  template<class B> inline constexpr bool negation_v = negation<B>::value;
+  template<class... B>
+    inline constexpr bool conjunction_v = conjunction<B...>::value;
+  template<class... B>
+    inline constexpr bool disjunction_v = disjunction<B...>::value;
+  template<class B>
+    inline constexpr bool negation_v = negation<B>::value;
 }
 \end{codeblock}
 
@@ -15399,11 +15412,12 @@
 
 \begin{codeblock}
 namespace std {
-  template <class T, T v>
-  struct integral_constant {
+  template <class T, T v> struct integral_constant {
     static constexpr T value = v;
+
     using value_type = T;
-    using type       = integral_constant<T, v>;
+    using type = integral_constant<T, v>;
+
     constexpr operator value_type() const noexcept { return value; }
     constexpr value_type operator()() const noexcept { return value; }
   };
@@ -15990,11 +16004,11 @@
 \pnum
 \begin{example}
 \begin{codeblock}
-is_const_v<const volatile int>     // \tcode{true}
-is_const_v<const int*>             // \tcode{false}
-is_const_v<const int&>             // \tcode{false}
-is_const_v<int[3]>                 // \tcode{false}
-is_const_v<const int[3]>           // \tcode{true}
+is_const_v<const volatile int>      // \tcode{true}
+is_const_v<const int*>              // \tcode{false}
+is_const_v<const int&>              // \tcode{false}
+is_const_v<int[3]>                  // \tcode{false}
+is_const_v<const int[3]>            // \tcode{true}
 \end{codeblock}
 \end{example}