folly/futures/Future.h

   1 /*
   2  * Copyright 2015 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #pragma once
  18
  19 #include <algorithm>
  20 #include <exception>
  21 #include <functional>
  22 #include <memory>
  23 #include <type_traits>
  24 #include <vector>
  25
  26 #include <folly/Optional.h>
  27 #include <folly/MoveWrapper.h>
  28 #include <folly/futures/Deprecated.h>
  29 #include <folly/futures/DrivableExecutor.h>
  30 #include <folly/futures/Promise.h>
  31 #include <folly/futures/Try.h>
  32 #include <folly/futures/FutureException.h>
  33 #include <folly/futures/detail/Types.h>
  34
  35 namespace folly {
  36
  37 template <class> struct Promise;
  38
  39 template <typename T>
  40 struct isFuture : std::false_type {
  41   typedef T Inner;
  42 };
  43
  44 template <typename T>
  45 struct isFuture<Future<T>> : std::true_type {
  46   typedef T Inner;
  47 };
  48
  49 template <typename T>
  50 struct isTry : std::false_type {};
  51
  52 template <typename T>
  53 struct isTry<Try<T>> : std::true_type {};
  54
  55 namespace detail {
  56
  57 template <class> struct Core;
  58 template <class...> struct VariadicContext;
  59 template <class> struct CollectContext;
  60
  61 template<typename F, typename... Args>
  62 using resultOf = decltype(std::declval<F>()(std::declval<Args>()...));
  63
  64 template <typename...>
  65 struct ArgType;
  66
  67 template <typename Arg, typename... Args>
  68 struct ArgType<Arg, Args...> {
  69   typedef Arg FirstArg;
  70 };
  71
  72 template <>
  73 struct ArgType<> {
  74   typedef void FirstArg;
  75 };
  76
  77 template <bool isTry, typename F, typename... Args>
  78 struct argResult {
  79   typedef resultOf<F, Args...> Result;
  80 };
  81
  82 template<typename F, typename... Args>
  83 struct callableWith {
  84     template<typename T,
  85              typename = detail::resultOf<T, Args...>>
  86     static constexpr std::true_type
  87     check(std::nullptr_t) { return std::true_type{}; };
  88
  89     template<typename>
  90     static constexpr std::false_type
  91     check(...) { return std::false_type{}; };
  92
  93     typedef decltype(check<F>(nullptr)) type;
  94     static constexpr bool value = type::value;
  95 };
  96
  97 template<typename T, typename F>
  98 struct callableResult {
  99   typedef typename std::conditional<
 100     callableWith<F>::value,
 101     detail::argResult<false, F>,
 102     typename std::conditional<
 103       callableWith<F, T&&>::value,
 104       detail::argResult<false, F, T&&>,
 105       typename std::conditional<
 106         callableWith<F, T&>::value,
 107         detail::argResult<false, F, T&>,
 108         typename std::conditional<
 109           callableWith<F, Try<T>&&>::value,
 110           detail::argResult<true, F, Try<T>&&>,
 111           detail::argResult<true, F, Try<T>&>>::type>::type>::type>::type Arg;
 112   typedef isFuture<typename Arg::Result> ReturnsFuture;
 113   typedef Future<typename ReturnsFuture::Inner> Return;
 114 };
 115
 116 template<typename F>
 117 struct callableResult<void, F> {
 118   typedef typename std::conditional<
 119     callableWith<F>::value,
 120     detail::argResult<false, F>,
 121     typename std::conditional<
 122       callableWith<F, Try<void>&&>::value,
 123       detail::argResult<true, F, Try<void>&&>,
 124       detail::argResult<true, F, Try<void>&>>::type>::type Arg;
 125   typedef isFuture<typename Arg::Result> ReturnsFuture;
 126   typedef Future<typename ReturnsFuture::Inner> Return;
 127 };
 128
 129 template <typename L>
 130 struct Extract : Extract<decltype(&L::operator())> { };
 131
 132 template <typename Class, typename R, typename... Args>
 133 struct Extract<R(Class::*)(Args...) const> {
 134   typedef isFuture<R> ReturnsFuture;
 135   typedef Future<typename ReturnsFuture::Inner> Return;
 136   typedef typename ReturnsFuture::Inner RawReturn;
 137   typedef typename ArgType<Args...>::FirstArg FirstArg;
 138 };
 139
 140 template <typename Class, typename R, typename... Args>
 141 struct Extract<R(Class::*)(Args...)> {
 142   typedef isFuture<R> ReturnsFuture;
 143   typedef Future<typename ReturnsFuture::Inner> Return;
 144   typedef typename ReturnsFuture::Inner RawReturn;
 145   typedef typename ArgType<Args...>::FirstArg FirstArg;
 146 };
 147
 148 } // detail
 149
 150 struct Timekeeper;
 151
 152 /// This namespace is for utility functions that would usually be static
 153 /// members of Future, except they don't make sense there because they don't
 154 /// depend on the template type (rather, on the type of their arguments in
 155 /// some cases). This is the least-bad naming scheme we could think of. Some
 156 /// of the functions herein have really-likely-to-collide names, like "map"
 157 /// and "sleep".
 158 namespace futures {
 159   /// Returns a Future that will complete after the specified duration. The
 160   /// Duration typedef of a `std::chrono` duration type indicates the
 161   /// resolution you can expect to be meaningful (milliseconds at the time of
 162   /// writing). Normally you wouldn't need to specify a Timekeeper, we will
 163   /// use the global futures timekeeper (we run a thread whose job it is to
 164   /// keep time for futures timeouts) but we provide the option for power
 165   /// users.
 166   ///
 167   /// The Timekeeper thread will be lazily created the first time it is
 168   /// needed. If your program never uses any timeouts or other time-based
 169   /// Futures you will pay no Timekeeper thread overhead.
 170   Future<void> sleep(Duration, Timekeeper* = nullptr);
 171
 172   /// Create a Future chain from a sequence of callbacks. i.e.
 173   ///
 174   ///   f.then(a).then(b).then(c);
 175   ///
 176   /// where f is a Future<A> and the result of the chain is a Future<Z>
 177   /// becomes
 178   ///
 179   ///   f.then(chain<A,Z>(a, b, c));
 180   // If anyone figures how to get chain to deduce A and Z, I'll buy you a drink.
 181   template <class A, class Z, class... Callbacks>
 182   std::function<Future<Z>(Try<A>)>
 183   chain(Callbacks... fns);
 184 }
 185
 186 template <class T>
 187 class Future {
 188  public:
 189   typedef T value_type;
 190
 191   // not copyable
 192   Future(Future const&) = delete;
 193   Future& operator=(Future const&) = delete;
 194
 195   // movable
 196   Future(Future&&) noexcept;
 197   Future& operator=(Future&&) noexcept;
 198
 199   // makeFuture
 200   template <class F = T>
 201   /* implicit */
 202   Future(const typename std::enable_if<!std::is_void<F>::value, F>::type& val);
 203
 204   template <class F = T>
 205   /* implicit */
 206   Future(typename std::enable_if<!std::is_void<F>::value, F>::type&& val);
 207
 208   template <class F = T,
 209             typename std::enable_if<std::is_void<F>::value, int>::type = 0>
 210   Future();
 211
 212   ~Future();
 213
 214   /** Return the reference to result. Should not be called if !isReady().
 215     Will rethrow the exception if an exception has been
 216     captured.
 217     */
 218   typename std::add_lvalue_reference<T>::type
 219   value();
 220   typename std::add_lvalue_reference<const T>::type
 221   value() const;
 222
 223   /// Returns an inactive Future which will call back on the other side of
 224   /// executor (when it is activated).
 225   ///
 226   /// NB remember that Futures activate when they destruct. This is good,
 227   /// it means that this will work:
 228   ///
 229   ///   f.via(e).then(a).then(b);
 230   ///
 231   /// a and b will execute in the same context (the far side of e), because
 232   /// the Future (temporary variable) created by via(e) does not call back
 233   /// until it destructs, which is after then(a) and then(b) have been wired
 234   /// up.
 235   ///
 236   /// But this is still racy:
 237   ///
 238   ///   f = f.via(e).then(a);
 239   ///   f.then(b);
 240   // The ref-qualifier allows for `this` to be moved out so we
 241   // don't get access-after-free situations in chaining.
 242   // https://akrzemi1.wordpress.com/2014/06/02/ref-qualifiers/
 243   template <typename Executor>
 244   Future<T> via(Executor* executor) &&;
 245
 246   /// This variant creates a new future, where the ref-qualifier && version
 247   /// moves `this` out. This one is less efficient but avoids confusing users
 248   /// when "return f.via(x);" fails.
 249   template <typename Executor>
 250   Future<T> via(Executor* executor) &;
 251
 252   /** True when the result (or exception) is ready. */
 253   bool isReady() const;
 254
 255   /** A reference to the Try of the value */
 256   Try<T>& getTry();
 257
 258   /// If the promise has been fulfilled, return an Optional with the Try<T>.
 259   /// Otherwise return an empty Optional.
 260   /// Note that this moves the Try<T> out.
 261   Optional<Try<T>> poll();
 262
 263   /// Block until the future is fulfilled. Returns the value (moved out), or
 264   /// throws the exception. The future must not already have a callback.
 265   T get();
 266
 267   /// Block until the future is fulfilled, or until timed out. Returns the
 268   /// value (moved out), or throws the exception (which might be a TimedOut
 269   /// exception).
 270   T get(Duration dur);
 271
 272   /// Call e->drive() repeatedly until the future is fulfilled. Examples
 273   /// of DrivableExecutor include EventBase and ManualExecutor. Returns the
 274   /// value (moved out), or throws the exception.
 275   T getVia(DrivableExecutor* e);
 276
 277   /// Unwraps the case of a Future<Future<T>> instance, and returns a simple
 278   /// Future<T> instance.
 279   template <class F = T>
 280   typename std::enable_if<isFuture<F>::value,
 281                           Future<typename isFuture<T>::Inner>>::type
 282   unwrap();
 283
 284   /** When this Future has completed, execute func which is a function that
 285     takes one of:
 286       (const) Try<T>&&
 287       (const) Try<T>&
 288       (const) Try<T>
 289       (const) T&&
 290       (const) T&
 291       (const) T
 292       (void)
 293
 294     Func shall return either another Future or a value.
 295
 296     A Future for the return type of func is returned.
 297
 298     Future<string> f2 = f1.then([](Try<T>&&) { return string("foo"); });
 299
 300     The Future given to the functor is ready, and the functor may call
 301     value(), which may rethrow if this has captured an exception. If func
 302     throws, the exception will be captured in the Future that is returned.
 303     */
 304   /* TODO n3428 and other async frameworks have something like then(scheduler,
 305      Future), we might want to support a similar API which could be
 306      implemented a little more efficiently than
 307      f.via(executor).then(callback) */
 308   template <typename F, typename R = detail::callableResult<T, F>>
 309   typename R::Return then(F func) {
 310     typedef typename R::Arg Arguments;
 311     return thenImplementation<F, R>(std::move(func), Arguments());
 312   }
 313
 314   /// Variant where func is an member function
 315   ///
 316   ///   struct Worker { R doWork(Try<T>); }
 317   ///
 318   ///   Worker *w;
 319   ///   Future<R> f2 = f1.then(&Worker::doWork, w);
 320   ///
 321   /// This is just sugar for
 322   ///
 323   ///   f1.then(std::bind(&Worker::doWork, w));
 324   template <typename R, typename Caller, typename... Args>
 325   Future<typename isFuture<R>::Inner>
 326   then(R(Caller::*func)(Args...), Caller *instance);
 327
 328   /// Convenience method for ignoring the value and creating a Future<void>.
 329   /// Exceptions still propagate.
 330   Future<void> then();
 331
 332   /// Set an error callback for this Future. The callback should take a single
 333   /// argument of the type that you want to catch, and should return a value of
 334   /// the same type as this Future, or a Future of that type (see overload
 335   /// below). For instance,
 336   ///
 337   /// makeFuture()
 338   ///   .then([] {
 339   ///     throw std::runtime_error("oh no!");
 340   ///     return 42;
 341   ///   })
 342   ///   .onError([] (std::runtime_error& e) {
 343   ///     LOG(INFO) << "std::runtime_error: " << e.what();
 344   ///     return -1; // or makeFuture<int>(-1)
 345   ///   });
 346   template <class F>
 347   typename std::enable_if<
 348     !detail::callableWith<F, exception_wrapper>::value &&
 349     !detail::Extract<F>::ReturnsFuture::value,
 350     Future<T>>::type
 351   onError(F&& func);
 352
 353   /// Overload of onError where the error callback returns a Future<T>
 354   template <class F>
 355   typename std::enable_if<
 356     !detail::callableWith<F, exception_wrapper>::value &&
 357     detail::Extract<F>::ReturnsFuture::value,
 358     Future<T>>::type
 359   onError(F&& func);
 360
 361   /// Overload of onError that takes exception_wrapper and returns Future<T>
 362   template <class F>
 363   typename std::enable_if<
 364     detail::callableWith<F, exception_wrapper>::value &&
 365     detail::Extract<F>::ReturnsFuture::value,
 366     Future<T>>::type
 367   onError(F&& func);
 368
 369   /// Overload of onError that takes exception_wrapper and returns T
 370   template <class F>
 371   typename std::enable_if<
 372     detail::callableWith<F, exception_wrapper>::value &&
 373     !detail::Extract<F>::ReturnsFuture::value,
 374     Future<T>>::type
 375   onError(F&& func);
 376
 377   /// func is like std::function<void()> and is executed unconditionally, and
 378   /// the value/exception is passed through to the resulting Future.
 379   /// func shouldn't throw, but if it does it will be captured and propagated,
 380   /// and discard any value/exception that this Future has obtained.
 381   template <class F>
 382   Future<T> ensure(F func);
 383
 384   /// Like onError, but for timeouts. example:
 385   ///
 386   ///   Future<int> f = makeFuture<int>(42)
 387   ///     .delayed(long_time)
 388   ///     .onTimeout(short_time,
 389   ///       []() -> int{ return -1; });
 390   ///
 391   /// or perhaps
 392   ///
 393   ///   Future<int> f = makeFuture<int>(42)
 394   ///     .delayed(long_time)
 395   ///     .onTimeout(short_time,
 396   ///       []() { return makeFuture<int>(some_exception); });
 397   template <class F>
 398   Future<T> onTimeout(Duration, F&& func, Timekeeper* = nullptr);
 399
 400   /// This is not the method you're looking for.
 401   ///
 402   /// This needs to be public because it's used by make* and when*, and it's
 403   /// not worth listing all those and their fancy template signatures as
 404   /// friends. But it's not for public consumption.
 405   template <class F>
 406   void setCallback_(F&& func);
 407
 408   /// A Future's callback is executed when all three of these conditions have
 409   /// become true: it has a value (set by the Promise), it has a callback (set
 410   /// by then), and it is active (active by default).
 411   ///
 412   /// Inactive Futures will activate upon destruction.
 413   Future<T>& activate() & {
 414     core_->activate();
 415     return *this;
 416   }
 417   Future<T>& deactivate() & {
 418     core_->deactivate();
 419     return *this;
 420   }
 421   Future<T> activate() && {
 422     core_->activate();
 423     return std::move(*this);
 424   }
 425   Future<T> deactivate() && {
 426     core_->deactivate();
 427     return std::move(*this);
 428   }
 429
 430   bool isActive() {
 431     return core_->isActive();
 432   }
 433
 434   template <class E>
 435   void raise(E&& exception) {
 436     raise(make_exception_wrapper<typename std::remove_reference<E>::type>(
 437         std::move(exception)));
 438   }
 439
 440   /// Raise an interrupt. If the promise holder has an interrupt
 441   /// handler it will be called and potentially stop asynchronous work from
 442   /// being done. This is advisory only - a promise holder may not set an
 443   /// interrupt handler, or may do anything including ignore. But, if you know
 444   /// your future supports this the most likely result is stopping or
 445   /// preventing the asynchronous operation (if in time), and the promise
 446   /// holder setting an exception on the future. (That may happen
 447   /// asynchronously, of course.)
 448   void raise(exception_wrapper interrupt);
 449
 450   void cancel() {
 451     raise(FutureCancellation());
 452   }
 453
 454   /// Throw TimedOut if this Future does not complete within the given
 455   /// duration from now. The optional Timeekeeper is as with futures::sleep().
 456   Future<T> within(Duration, Timekeeper* = nullptr);
 457
 458   /// Throw the given exception if this Future does not complete within the
 459   /// given duration from now. The optional Timeekeeper is as with
 460   /// futures::sleep().
 461   template <class E>
 462   Future<T> within(Duration, E exception, Timekeeper* = nullptr);
 463
 464   /// Delay the completion of this Future for at least this duration from
 465   /// now. The optional Timekeeper is as with futures::sleep().
 466   Future<T> delayed(Duration, Timekeeper* = nullptr);
 467
 468   /// Block until this Future is complete. Returns a reference to this Future.
 469   Future<T>& wait() &;
 470
 471   /// Overload of wait() for rvalue Futures
 472   Future<T>&& wait() &&;
 473
 474   /// Block until this Future is complete or until the given Duration passes.
 475   /// Returns a reference to this Future
 476   Future<T>& wait(Duration) &;
 477
 478   /// Overload of wait(Duration) for rvalue Futures
 479   Future<T>&& wait(Duration) &&;
 480
 481   /// Call e->drive() repeatedly until the future is fulfilled. Examples
 482   /// of DrivableExecutor include EventBase and ManualExecutor. Returns a
 483   /// reference to this Future so that you can chain calls if desired.
 484   /// value (moved out), or throws the exception.
 485   Future<T>& waitVia(DrivableExecutor* e) &;
 486
 487   /// Overload of waitVia() for rvalue Futures
 488   Future<T>&& waitVia(DrivableExecutor* e) &&;
 489
 490   /// If the value in this Future is equal to the given Future, when they have
 491   /// both completed, the value of the resulting Future<bool> will be true. It
 492   /// will be false otherwise (including when one or both Futures have an
 493   /// exception)
 494   Future<bool> willEqual(Future<T>&);
 495
 496   /// predicate behaves like std::function<bool(T const&)>
 497   /// If the predicate does not obtain with the value, the result
 498   /// is a folly::PredicateDoesNotObtain exception
 499   template <class F>
 500   Future<T> filter(F predicate);
 501
 502  protected:
 503   typedef detail::Core<T>* corePtr;
 504
 505   // shared core state object
 506   corePtr core_;
 507
 508   explicit
 509   Future(corePtr obj) : core_(obj) {}
 510
 511   void detach();
 512
 513   void throwIfInvalid() const;
 514
 515   friend class Promise<T>;
 516   template <class> friend class Future;
 517
 518   // Variant: returns a value
 519   // e.g. f.then([](Try<T> t){ return t.value(); });
 520   template <typename F, typename R, bool isTry, typename... Args>
 521   typename std::enable_if<!R::ReturnsFuture::value, typename R::Return>::type
 522   thenImplementation(F func, detail::argResult<isTry, F, Args...>);
 523
 524   // Variant: returns a Future
 525   // e.g. f.then([](Try<T> t){ return makeFuture<T>(t); });
 526   template <typename F, typename R, bool isTry, typename... Args>
 527   typename std::enable_if<R::ReturnsFuture::value, typename R::Return>::type
 528   thenImplementation(F func, detail::argResult<isTry, F, Args...>);
 529
 530   Executor* getExecutor() { return core_->getExecutor(); }
 531   void setExecutor(Executor* x) { core_->setExecutor(x); }
 532 };
 533
 534 /**
 535   Make a completed Future by moving in a value. e.g.
 536
 537     string foo = "foo";
 538     auto f = makeFuture(std::move(foo));
 539
 540   or
 541
 542     auto f = makeFuture<string>("foo");
 543 */
 544 template <class T>
 545 Future<typename std::decay<T>::type> makeFuture(T&& t);
 546
 547 /** Make a completed void Future. */
 548 Future<void> makeFuture();
 549
 550 /** Make a completed Future by executing a function. If the function throws
 551   we capture the exception, otherwise we capture the result. */
 552 template <class F>
 553 auto makeFutureTry(
 554   F&& func,
 555   typename std::enable_if<
 556     !std::is_reference<F>::value, bool>::type sdf = false)
 557   -> Future<decltype(func())>;
 558
 559 template <class F>
 560 auto makeFutureTry(
 561   F const& func)
 562   -> Future<decltype(func())>;
 563
 564 /// Make a failed Future from an exception_ptr.
 565 /// Because the Future's type cannot be inferred you have to specify it, e.g.
 566 ///
 567 ///   auto f = makeFuture<string>(std::current_exception());
 568 template <class T>
 569 Future<T> makeFuture(std::exception_ptr const& e) DEPRECATED;
 570
 571 /// Make a failed Future from an exception_wrapper.
 572 template <class T>
 573 Future<T> makeFuture(exception_wrapper ew);
 574
 575 /** Make a Future from an exception type E that can be passed to
 576   std::make_exception_ptr(). */
 577 template <class T, class E>
 578 typename std::enable_if<std::is_base_of<std::exception, E>::value,
 579                         Future<T>>::type
 580 makeFuture(E const& e);
 581
 582 /** Make a Future out of a Try */
 583 template <class T>
 584 Future<T> makeFuture(Try<T>&& t);
 585
 586 /*
 587  * Return a new Future that will call back on the given Executor.
 588  * This is just syntactic sugar for makeFuture().via(executor)
 589  *
 590  * @param executor the Executor to call back on
 591  *
 592  * @returns a void Future that will call back on the given executor
 593  */
 594 template <typename Executor>
 595 Future<void> via(Executor* executor);
 596
 597 /** When all the input Futures complete, the returned Future will complete.
 598   Errors do not cause early termination; this Future will always succeed
 599   after all its Futures have finished (whether successfully or with an
 600   error).
 601
 602   The Futures are moved in, so your copies are invalid. If you need to
 603   chain further from these Futures, use the variant with an output iterator.
 604
 605   This function is thread-safe for Futures running on different threads. But
 606   if you are doing anything non-trivial after, you will probably want to
 607   follow with `via(executor)` because it will complete in whichever thread the
 608   last Future completes in.
 609
 610   The return type for Future<T> input is a Future<std::vector<Try<T>>>
 611   */
 612 template <class InputIterator>
 613 Future<std::vector<Try<
 614   typename std::iterator_traits<InputIterator>::value_type::value_type>>>
 615 whenAll(InputIterator first, InputIterator last);
 616
 617 /// This version takes a varying number of Futures instead of an iterator.
 618 /// The return type for (Future<T1>, Future<T2>, ...) input
 619 /// is a Future<std::tuple<Try<T1>, Try<T2>, ...>>.
 620 /// The Futures are moved in, so your copies are invalid.
 621 template <typename... Fs>
 622 typename detail::VariadicContext<
 623   typename std::decay<Fs>::type::value_type...>::type
 624 whenAll(Fs&&... fs);
 625
 626 /// Like whenAll, but will short circuit on the first exception. Thus, the
 627 /// type of the returned Future is std::vector<T> instead of
 628 /// std::vector<Try<T>>
 629 template <class InputIterator>
 630 Future<typename detail::CollectContext<
 631   typename std::iterator_traits<InputIterator>::value_type::value_type
 632 >::result_type>
 633 collect(InputIterator first, InputIterator last);
 634
 635 /** The result is a pair of the index of the first Future to complete and
 636   the Try. If multiple Futures complete at the same time (or are already
 637   complete when passed in), the "winner" is chosen non-deterministically.
 638
 639   This function is thread-safe for Futures running on different threads.
 640   */
 641 template <class InputIterator>
 642 Future<std::pair<
 643   size_t,
 644   Try<typename std::iterator_traits<InputIterator>::value_type::value_type>>>
 645 whenAny(InputIterator first, InputIterator last);
 646
 647 /** when n Futures have completed, the Future completes with a vector of
 648   the index and Try of those n Futures (the indices refer to the original
 649   order, but the result vector will be in an arbitrary order)
 650
 651   Not thread safe.
 652   */
 653 template <class InputIterator>
 654 Future<std::vector<std::pair<
 655   size_t,
 656   Try<typename std::iterator_traits<InputIterator>::value_type::value_type>>>>
 657 whenN(InputIterator first, InputIterator last, size_t n);
 658
 659 template <typename F, typename T, typename ItT>
 660 using MaybeTryArg = typename std::conditional<
 661   detail::callableWith<F, T&&, Try<ItT>&&>::value, Try<ItT>, ItT>::type;
 662
 663 template<typename F, typename T, typename Arg>
 664 using isFutureResult = isFuture<typename std::result_of<F(T&&, Arg&&)>::type>;
 665
 666 /** repeatedly calls func on every result, e.g.
 667     reduce(reduce(reduce(T initial, result of first), result of second), ...)
 668
 669     The type of the final result is a Future of the type of the initial value.
 670
 671     Func can either return a T, or a Future<T>
 672   */
 673 template <class It, class T, class F,
 674           class ItT = typename std::iterator_traits<It>::value_type::value_type,
 675           class Arg = MaybeTryArg<F, T, ItT>>
 676 typename std::enable_if<!isFutureResult<F, T, Arg>::value, Future<T>>::type
 677 reduce(It first, It last, T initial, F func);
 678
 679 template <class It, class T, class F,
 680           class ItT = typename std::iterator_traits<It>::value_type::value_type,
 681           class Arg = MaybeTryArg<F, T, ItT>>
 682 typename std::enable_if<isFutureResult<F, T, Arg>::value, Future<T>>::type
 683 reduce(It first, It last, T initial, F func);
 684
 685 } // folly
 686
 687 #include <folly/futures/Future-inl.h>