P0318R1 unwrap_ref_decay and unwrap_reference

Add the type trait as subclause [refwrap.unwrapref],
instead of as a sibling of [refwrap].
Rephrase the wording to avoid referencing X before it
is introduced.
Do not refer to 'equals' as referring to types.

Author: jensmaurer

source/utilities.tex

@@ -854,12 +854,10 @@
 \end{itemdecl}
 
 \begin{itemdescr}
+Let \tcode{Vi} be \tcode{unwrap_ref_decay_t<Ti>}.
+
 \pnum
-\returns \tcode{pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))},
-where \tcode{V1} and \tcode{V2} are determined as follows: Let \tcode{Ui} be
-\tcode{decay_t<Ti>} for each \tcode{Ti}. If \tcode{Ui} is a specialization
-of \tcode{reference_wrapper}, then \tcode{Vi} is \tcode{Ui::type\&},
-otherwise \tcode{Vi} is \tcode{Ui}.
+\returns \tcode{pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))}.
 \end{itemdescr}
 
 \pnum
@@ -1601,10 +1599,7 @@
 
 \begin{itemdescr}
 \pnum
-The pack \tcode{VTypes} is defined as follows. Let \tcode{U}$_i$ be \tcode{decay_t<T$_i$>} for each
-\tcode{T}$_i$ in \tcode{TTypes}. If \tcode{U}$_i$ is a specialization of
-\tcode{reference_wrapper}, then \tcode{V}$_i$ in \tcode{VTypes} is \tcode{U$_i$::type\&},
-otherwise \tcode{V}$_i$ is \tcode{U}$_i$.
+Let \tcode{VTypes...} be \tcode{unwrap_ref_decay_t<TTypes>...}.
 
 \pnum
 \returns \tcode{tuple<VTypes...>(std::forward<TTypes>(t)...)}.
@@ -12944,6 +12939,8 @@
 \rSec2[functional.syn]{Header \tcode{<functional>} synopsis}
 
 \indexhdr{functional}%
+\indexlibrary{unwrap_ref_decay}%
+\indexlibrary{unwrap_ref_decay_t}%
 \begin{codeblock}
 namespace std {
   // \ref{func.invoke}, invoke
@@ -12962,6 +12959,10 @@
   template<class T> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
   template<class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
 
+  template<class T> struct unwrap_reference;
+  template<class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> {};
+  template<class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
+
   // \ref{arithmetic.operations}, arithmetic operations
   template<class T = void> struct plus;
   template<class T = void> struct minus;
@@ -13318,7 +13319,6 @@
 \pnum\returns The stored reference.
 \end{itemdescr}
 
-
 \rSec3[refwrap.invoke]{Invocation}
 
 \indexlibrarymember{operator()}{reference_wrapper}%
@@ -13371,6 +13371,20 @@
 \pnum\returns \tcode{cref(t.get())}.
 \end{itemdescr}
 
+\rSec3[refwrap.unwrapref]{Transformation type trait \tcode{unwrap_reference}}
+
+\indexlibrary{unwrap_reference}%
+\begin{itemdecl}
+template<class T>
+  struct unwrap_reference;
+\end{itemdecl}
+
+\pnum
+If \tcode{T} is
+a specialization \tcode{reference_wrapper<X>} for some type \tcode{X},
+the member typedef \tcode{type} of \tcode{unwrap_reference<T>} is \tcode{X\&},
+otherwise it is \tcode{T}.
+
 \rSec2[arithmetic.operations]{Arithmetic operations}
 
 \pnum