P1317R2 Remove return type deduction in std::apply

This commit adds "tuple-like<Tuple> is true and" to the definition of
apply_result. LWG noticed this was needed but we were unable to contact
the paper author to make the change in time for plenary.

Author: jwakely

source/meta.tex

@@ -295,6 +295,9 @@
   template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
   template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
+  template<class Fn, class Tuple> struct is_applicable;
+  template<class Fn, class Tuple> struct is_nothrow_applicable;
+
   // \ref{meta.trans.cv}, const-volatile modifications
   template<class T> struct remove_const;
   template<class T> struct remove_volatile;
@@ -367,6 +370,7 @@
   template<class... T> struct common_reference;
   template<class T> struct underlying_type;
   template<class Fn, class... ArgTypes> struct invoke_result;
+  template<class Fn, class Tuple> struct apply_result;
   template<class T> struct unwrap_reference;
   template<class T> struct unwrap_ref_decay;
 
@@ -388,6 +392,8 @@
     using @\libglobal{underlying_type_t}@  = typename underlying_type<T>::type;
   template<class Fn, class... ArgTypes>
     using @\libglobal{invoke_result_t}@    = typename invoke_result<Fn, ArgTypes...>::type;
+  template<class Fn, class Tuple>
+    using @\libglobal{apply_result_t}@     = typename apply_result<Fn, Tuple>::type;
   template<class T>
     using unwrap_reference_t = typename unwrap_reference<T>::type;
   template<class T>
@@ -598,6 +604,10 @@
   template<class R, class Fn, class... ArgTypes>
     constexpr bool is_nothrow_invocable_r_v
       = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+  template<class Fn, class Tuple>
+    constexpr bool @\libglobal{is_applicable_v}@ = is_applicable<Fn, Tuple>::value;
+  template<class Fn, class Tuple>
+    constexpr bool @\libglobal{is_nothrow_applicable_v}@ = is_nothrow_applicable<Fn, Tuple>::value;
 
   // \ref{meta.logical}, logical operator traits
   template<class... B>
@@ -920,6 +930,13 @@
 \tcode{true_type} if the corresponding condition is \tcode{true}, otherwise
 \tcode{false_type}.
 
+\pnum
+Let \tcode{\placeholdernc{ELEMS-OF}(T)} be the parameter pack
+\tcode{get<\exposid{N}>(declval<T>())}, where \exposid{N} is the pack of
+\tcode{size_t} template arguments of the specialization of
+\tcode{index_sequence} denoted by
+\tcode{make_index_sequence<tuple_size_v<remove_reference_t<T>>>}.
+
 \rSec3[meta.unary.cat]{Primary type categories}
 
 \pnum
@@ -1879,6 +1896,27 @@
  is known not to throw any exceptions\iref{expr.unary.noexcept}       &
  \tcode{Fn}, \tcode{R}, and all types in the template parameter pack \tcode{ArgTypes}
  shall be complete types, \cv{}~\keyword{void}, or
+ arrays of unknown bound.                                             \\ \rowsep
+
+\indexlibraryglobal{is_applicable}%
+\tcode{template<class Fn, class Tuple>}\br
+ \tcode{struct is_applicable;}              &
+ \tcode{\exposconcept{tuple-like}<Tuple>} is \tcode{true} and
+ the expression
+ \tcode{\placeholdernc{INVOKE}(declval<Fn>(), \placeholdernc{ELEMS-OF}(Tuple)...)}
+ is well-formed when treated as an unevaluated operand.       &
+ \tcode{Fn} and \tcode{Tuple}
+ shall be complete types, \cv{}~\keyword{void}, or
+ arrays of unknown bound.                                             \\ \rowsep
+
+\indexlibraryglobal{is_nothrow_applicable}%
+\tcode{template<class Fn, class Tuple>}\br
+ \tcode{struct is_nothrow_applicable;}              &
+ \tcode{is_applicable_v<}\br\tcode{Fn, Tuple>} is \tcode{true} and
+ the expression \tcode{\placeholdernc{INVOKE}(declval<Fn>(), \placeholdernc{ELEMS-OF}(Tuple)...)}
+ is known not to throw any exceptions\iref{expr.unary.noexcept}.       &
+ \tcode{Fn} and \tcode{Tuple}
+ shall be complete types, \cv{}~\keyword{void}, or
  arrays of unknown bound.                                             \\
 \end{libreqtab3f}
 
@@ -2320,6 +2358,32 @@
  are complete types, \cv{}~\keyword{void}, or arrays of
  unknown bound.\\ \rowsep
 
+\tcode{template<class Fn, class Tuple>}\br
+ \tcode{struct \libglobal{apply_result};}
+ &
+ If \tcode{\exposconcept{tuple-like}<Tuple>} is \tcode{true}
+ and the expression
+ \tcode{\placeholdernc{INVOKE}(declval<Fn>(), \placeholdernc{ELEMS-OF}(Tuple)...)}\iref{func.require}
+ is well-formed
+ when treated as an unevaluated operand\iref{term.unevaluated.operand},
+ the member typedef \tcode{type} denotes the type
+ \tcode{decltype(\placeholdernc{INVOKE}(declval<Fn>(), \placeholdernc{ELEMS-OF}(Tuple)...))};
+ otherwise, there shall be no member \tcode{type}.
+ Access checking is performed as if in a context unrelated to \tcode{Fn}
+ and \tcode{Tuple}.
+ Only the validity of the immediate context of the expression is considered.
+ \begin{note}
+ The compilation of the expression can result in side effects
+ such as the instantiation of class template specializations
+ and function template specializations,
+ the generation of implicitly-defined functions, and so on.
+ Such side effects are not in the ``immediate context''
+ and can result in the program being ill-formed.
+ \end{note}
+ \expects
+ \tcode{Fn} and \tcode{Tuple} are complete types, \cv{}~\keyword{void},
+ or arrays of unknown bound.\\ \rowsep
+
 \tcode{template<class T>} \tcode{struct \libglobal{unwrap_reference};}
  &
  If \tcode{T} is

source/utilities.tex

@@ -1569,7 +1569,8 @@
 
   // \ref{tuple.apply}, calling a function with a tuple of arguments
   template<class F, @\exposconceptnc{tuple-like}@ Tuple>
-    constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(@\seebelow@);
+    constexpr apply_result_t<F, Tuple> apply(F&& f, Tuple&& t)
+      noexcept(is_nothrow_applicable_v<F, Tuple>);
 
   template<class T, @\exposconceptnc{tuple-like}@ Tuple>
     constexpr T make_from_tuple(Tuple&& t);
@@ -2688,7 +2689,8 @@
 \indexlibraryglobal{apply}%
 \begin{itemdecl}
 template<class F, @\exposconcept{tuple-like}@ Tuple>
-  constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(@\seebelow@);
+  constexpr apply_result_t<F, Tuple> apply(F&& f, Tuple&& t)
+    noexcept(is_nothrow_applicable_v<F, Tuple>);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2709,15 +2711,6 @@
 return @\placeholdernc{apply-impl}@(std::forward<F>(f), std::forward<Tuple>(t),
                   make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});
 \end{codeblock}
-
-\pnum
-\remarks
-Let \tcode{I} be the pack
-\tcode{0, 1, $\dotsc$, (tuple_size_v<remove_reference_t<Tuple>> - 1)}.
-The exception specification is equivalent to:
-\begin{codeblock}
-noexcept(invoke(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))
-\end{codeblock}
 \end{itemdescr}
 
 \indexlibraryglobal{make_from_tuple}%