Implement thenTry and thenValue in terms of thenImplementation

Summary:
Modify the implementations of thenValue and thenError to be in terms of thenImplementation rather than then.

This is a preliminary transformation before splitting then and deprecating parts of it in turn.

Reviewed By: marshallcline

Differential Revision: D9494305

fbshipit-source-id: 38cd165866f98514ee506dc01f625b7df1db211b

folly/futures/Future-inl.h

@@ -1080,23 +1080,27 @@ template <class T>
 template <typename F>
 Future<typename futures::detail::tryCallableResult<T, F>::value_type>
 Future<T>::thenTry(F&& func) && {
-  return std::move(*this).then(
-      [f = std::forward<F>(func)](folly::Try<T>&& t) mutable {
-        return std::forward<F>(f)(std::move(t));
-      });
+  auto lambdaFunc = [f = std::forward<F>(func)](folly::Try<T>&& t) mutable {
+    return std::forward<F>(f)(std::move(t));
+  };
+  using R = futures::detail::tryCallableResult<T, decltype(lambdaFunc)>;
+  return this->template thenImplementation<decltype(lambdaFunc), R>(
+      std::move(lambdaFunc), typename R::Arg());
 }
 
 template <class T>
 template <typename F>
 Future<typename futures::detail::valueCallableResult<T, F>::value_type>
 Future<T>::thenValue(F&& func) && {
-  return std::move(*this).then([f = std::forward<F>(func)](
-                                   folly::Try<T>&& t) mutable {
+  auto lambdaFunc = [f = std::forward<F>(func)](folly::Try<T>&& t) mutable {
     return std::forward<F>(f)(
         t.template get<
             false,
             typename futures::detail::valueCallableResult<T, F>::FirstArg>());
-  });
+  };
+  using R = futures::detail::tryCallableResult<T, decltype(lambdaFunc)>;
+  return this->template thenImplementation<decltype(lambdaFunc), R>(
+      std::move(lambdaFunc), typename R::Arg());
 }
 
 template <class T>

folly/futures/Future-pre.h

@@ -113,6 +113,7 @@ struct tryCallableResult {
       detail::argResult<true, F, Try<T>&&>>::type Arg;
   typedef isFutureOrSemiFuture<typename Arg::Result> ReturnsFuture;
   typedef typename ReturnsFuture::Inner value_type;
+  typedef Future<value_type> Return;
 };
 
 template <typename T, typename F>
@@ -121,6 +122,7 @@ struct valueCallableResult {
   typedef isFutureOrSemiFuture<typename Arg::Result> ReturnsFuture;
   typedef typename ReturnsFuture::Inner value_type;
   typedef typename Arg::ArgList::FirstArg FirstArg;
+  typedef Future<value_type> Return;
 };
 
 template <typename L>