Provide a unpackTryTuple function in folly

Summary: This feature already exists in detail, move it to public instead.

Reviewed By: andriigrynenko

Differential Revision: D4013691

fbshipit-source-id: 1779cc53d114ddc97993b41e0ad63c104008f6b0

folly/Makefile.am

@@ -77,6 +77,7 @@ nobase_follyinclude_HEADERS = \
 	detail/StaticSingletonManager.h \
 	detail/Stats.h \
 	detail/ThreadLocalDetail.h \
+  detail/TryDetail.h \
 	detail/TurnSequencer.h \
 	detail/UncaughtExceptionCounter.h \
 	Demangle.h \

folly/Try-inl.h

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <folly/detail/TryDetail.h>
 #include <stdexcept>
 
 namespace folly {
@@ -173,4 +174,10 @@ makeTryWith(F&& f) {
   }
 }
 
+template <typename... Ts>
+std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts) {
+  return detail::TryTuple<Ts...>::unwrap(
+      std::forward<std::tuple<folly::Try<Ts>...>>(ts));
+}
+
 } // folly

folly/Try.h

@@ -418,6 +418,9 @@ typename std::enable_if<
   Try<void>>::type
 makeTryWith(F&& f);
 
+template <typename... Ts>
+std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts);
+
 } // folly
 
 #include <folly/Try-inl.h>

folly/detail/TryDetail.h

+/*
+ * Copyright 2016 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace folly {
+namespace detail {
+
+template <typename... Ts>
+struct TryTuple {
+  template <typename... Ts2>
+  static std::tuple<Ts...> unwrap(
+      std::tuple<folly::Try<Ts>...>&& o,
+      Ts2&&... ts2) {
+    static_assert(
+        sizeof...(ts2) < std::tuple_size<std::tuple<folly::Try<Ts>...>>::value,
+        "Non-templated unwrap should be used instead");
+
+    return unwrap(
+        std::move(o),
+        std::forward<Ts2>(ts2)...,
+        std::move(*std::get<sizeof...(ts2)>(o)));
+  }
+
+  static std::tuple<Ts...> unwrap(
+      std::tuple<folly::Try<Ts>...>&& /* o */,
+      Ts&&... ts) {
+    return std::tuple<Ts...>(std::forward<Ts>(ts)...);
+  }
+};
+
+} // namespace detail
+} // namespace folly

folly/futures/detail/Core.h

@@ -468,32 +468,13 @@ struct CollectVariadicContext {
   }
   ~CollectVariadicContext() {
     if (!threw.exchange(true)) {
-      p.setValue(unwrap(std::move(results)));
+      p.setValue(unwrapTryTuple(std::move(results)));
     }
   }
   Promise<std::tuple<Ts...>> p;
   std::tuple<folly::Try<Ts>...> results;
   std::atomic<bool> threw {false};
   typedef Future<std::tuple<Ts...>> type;
-
- private:
-  template <typename... Ts2>
-  static std::tuple<Ts...> unwrap(std::tuple<folly::Try<Ts>...>&& o,
-                                  Ts2&&... ts2) {
-    static_assert(sizeof...(ts2) <
-                  std::tuple_size<std::tuple<folly::Try<Ts>...>>::value,
-                  "Non-templated unwrap should be used instead");
-    assert(std::get<sizeof...(ts2)>(o).hasValue());
-
-    return unwrap(std::move(o),
-                  std::forward<Ts2>(ts2)...,
-                  std::move(*std::get<sizeof...(ts2)>(o)));
-  }
-
-  static std::tuple<Ts...> unwrap(std::tuple<folly::Try<Ts>...>&& /* o */,
-                                  Ts&&... ts) {
-    return std::tuple<Ts...>(std::forward<Ts>(ts)...);
-  }
 };
 
 template <template <typename...> class T, typename... Ts>