Future.h

Go to the documentation of this file.

/*
 * Copyright 2014-present 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

#include <algorithm>
#include <exception>
#include <functional>
#include <memory>
#include <type_traits>
#include <vector>

#include <folly/Optional.h>
#include <folly/Portability.h>
#include <folly/ScopeGuard.h>
#include <folly/Try.h>
#include <folly/Unit.h>
#include <folly/Utility.h>
#include <folly/executors/DrivableExecutor.h>
#include <folly/executors/TimedDrivableExecutor.h>
#include <folly/functional/Invoke.h>
#include <folly/futures/Promise.h>
#include <folly/futures/detail/Types.h>
#include <folly/lang/Exception.h>

#if FOLLY_HAS_COROUTINES
#include <folly/experimental/coro/Traits.h>
#include <experimental/coroutine>
#endif

// boring predeclarations and details
#include <folly/futures/Future-pre.h>

// not-boring helpers, e.g. all in folly::futures, makeFuture variants, etc.
// Needs to be included after Future-pre.h and before Future-inl.h
#include <folly/futures/helpers.h>

namespace folly {

class FOLLY_EXPORT FutureException : public std::logic_error {
 public:
  using std::logic_error::logic_error;
};

class FOLLY_EXPORT FutureInvalid : public FutureException {
 public:
  FutureInvalid() : FutureException("Future invalid") {}
};

class FOLLY_EXPORT FutureAlreadyContinued : public FutureException {
 public:
  FutureAlreadyContinued() : FutureException("Future already continued") {}
};

class FOLLY_EXPORT FutureNotReady : public FutureException {
 public:
  FutureNotReady() : FutureException("Future not ready") {}
};

class FOLLY_EXPORT FutureCancellation : public FutureException {
 public:
  FutureCancellation() : FutureException("Future was cancelled") {}
};

class FOLLY_EXPORT FutureTimeout : public FutureException {
 public:
  FutureTimeout() : FutureException("Timed out") {}
};

class FOLLY_EXPORT FuturePredicateDoesNotObtain : public FutureException {
 public:
  FuturePredicateDoesNotObtain()
      : FutureException("Predicate does not obtain") {}
};

class FOLLY_EXPORT FutureNoTimekeeper : public FutureException {
 public:
  FutureNoTimekeeper() : FutureException("No timekeeper available") {}
};

class FOLLY_EXPORT FutureNoExecutor : public FutureException {
 public:
  FutureNoExecutor() : FutureException("No executor provided to via") {}
};

template <class T>
class Future;

template <class T>
class SemiFuture;

template <class T>
class FutureSplitter;

namespace futures {
namespace detail {
template <class T>
class FutureBase {
 public:
  typedef T value_type;

  template <
      class T2 = T,
      typename = typename std::enable_if<
          !isFuture<typename std::decay<T2>::type>::value &&
          !isSemiFuture<typename std::decay<T2>::type>::value>::type>
  /* implicit */ FutureBase(T2&& val);

  template <class T2 = T>
  /* implicit */ FutureBase(
      typename std::enable_if<std::is_same<Unit, T2>::value>::type*);

  template <
      class... Args,
      typename std::enable_if<std::is_constructible<T, Args&&...>::value, int>::
          type = 0>
  explicit FutureBase(in_place_t, Args&&... args);

  FutureBase(FutureBase<T> const&) = delete;
  FutureBase(SemiFuture<T>&&) noexcept;
  FutureBase(Future<T>&&) noexcept;

  // not copyable
  FutureBase(Future<T> const&) = delete;
  FutureBase(SemiFuture<T> const&) = delete;

  ~FutureBase();

  bool valid() const noexcept {
    return core_ != nullptr;
  }

  T& value() &;
  T const& value() const&;
  T&& value() &&;
  T const&& value() const&&;

  Try<T>& result() &;
  Try<T> const& result() const&;
  Try<T>&& result() &&;
  Try<T> const&& result() const&&;

  bool isReady() const;

  bool hasValue() const;

  bool hasException() const;

  Optional<Try<T>> poll();

  template <class F>
  void setCallback_(F&& func);

  template <class F>
  void setCallback_(F&& func, std::shared_ptr<folly::RequestContext> context);

  void raise(exception_wrapper interrupt);

  template <class E>
  void raise(E&& exception) {
    raise(make_exception_wrapper<typename std::remove_reference<E>::type>(
        std::forward<E>(exception)));
  }

  void cancel() {
    raise(FutureCancellation());
  }

  // Returns this future's executor priority.
  int8_t getPriority() const {
    return getCore().getPriority();
  }

 protected:
  friend class Promise<T>;
  template <class>
  friend class SemiFuture;
  template <class>
  friend class Future;

  using Core = futures::detail::Core<T>;

  // Throws FutureInvalid if there is no shared state object; else returns it
  // by ref.
  //
  // Implementation methods should usually use this instead of `this->core_`.
  // The latter should be used only when you need the possibly-null pointer.
  Core& getCore() {
    return getCoreImpl(*this);
  }
  Core const& getCore() const {
    return getCoreImpl(*this);
  }

  template <typename Self>
  static decltype(auto) getCoreImpl(Self& self) {
    if (!self.core_) {
      throw_exception<FutureInvalid>();
    }
    return *self.core_;
  }

  Try<T>& getCoreTryChecked() {
    return getCoreTryChecked(*this);
  }
  Try<T> const& getCoreTryChecked() const {
    return getCoreTryChecked(*this);
  }

  template <typename Self>
  static decltype(auto) getCoreTryChecked(Self& self) {
    auto& core = self.getCore();
    if (!core.hasResult()) {
      throw_exception<FutureNotReady>();
    }
    return core.getTry();
  }

  // shared core state object
  // usually you should use `getCore()` instead of directly accessing `core_`.
  Core* core_;

  explicit FutureBase(Core* obj) : core_(obj) {}

  explicit FutureBase(futures::detail::EmptyConstruct) noexcept;

  void detach();

  void throwIfInvalid() const;
  void throwIfContinued() const;

  void assign(FutureBase<T>&& other) noexcept;

  Executor* getExecutor() const {
    return getCore().getExecutor();
  }

  // Sets the Executor within the Core state object of `this`.
  // Must be called either before attaching a callback or after the callback
  // has already been invoked, but not concurrently with anything which might
  // trigger invocation of the callback.
  void setExecutor(Executor* x, int8_t priority = Executor::MID_PRI) {
    getCore().setExecutor(x, priority);
  }

  void setExecutor(
      Executor::KeepAlive<> x,
      int8_t priority = Executor::MID_PRI) {
    getCore().setExecutor(std::move(x), priority);
  }

  // Variant: returns a value
  // e.g. f.thenTry([](Try<T> t){ return t.value(); });
  template <typename F, typename R>
  typename std::enable_if<!R::ReturnsFuture::value, typename R::Return>::type
  thenImplementation(F&& func, R);

  // Variant: returns a Future
  // e.g. f.thenTry([](Try<T> t){ return makeFuture<T>(t); });
  template <typename F, typename R>
  typename std::enable_if<R::ReturnsFuture::value, typename R::Return>::type
  thenImplementation(F&& func, R);

  template <typename E>
  SemiFuture<T> withinImplementation(Duration dur, E e, Timekeeper* tk) &&;
};
template <class T>
void convertFuture(SemiFuture<T>&& sf, Future<T>& f);

class DeferredExecutor;

template <typename T>
DeferredExecutor* getDeferredExecutor(SemiFuture<T>& future);

template <typename T>
folly::Executor::KeepAlive<DeferredExecutor> stealDeferredExecutor(
    SemiFuture<T>& future);
} // namespace detail
} // namespace futures

template <class T>
class SemiFuture : private futures::detail::FutureBase<T> {
 private:
  using Base = futures::detail::FutureBase<T>;
  using DeferredExecutor = futures::detail::DeferredExecutor;
  using TimePoint = std::chrono::system_clock::time_point;

 public:
  ~SemiFuture();

  static SemiFuture<T> makeEmpty();

  using typename Base::value_type;

  template <
      class T2 = T,
      typename = typename std::enable_if<
          !isFuture<typename std::decay<T2>::type>::value &&
          !isSemiFuture<typename std::decay<T2>::type>::value>::type>
  /* implicit */ SemiFuture(T2&& val) : Base(std::forward<T2>(val)) {}

  template <class T2 = T>
  /* implicit */ SemiFuture(
      typename std::enable_if<std::is_same<Unit, T2>::value>::type* p = nullptr)
      : Base(p) {}

  template <
      class... Args,
      typename std::enable_if<std::is_constructible<T, Args&&...>::value, int>::
          type = 0>
  explicit SemiFuture(in_place_t, Args&&... args)
      : Base(in_place, std::forward<Args>(args)...) {}

  SemiFuture(SemiFuture<T> const&) = delete;
  // movable
  SemiFuture(SemiFuture<T>&&) noexcept;
  // safe move-constructabilty from Future
  /* implicit */ SemiFuture(Future<T>&&) noexcept;

  using Base::cancel;
  using Base::getPriority;
  using Base::hasException;
  using Base::hasValue;
  using Base::isReady;
  using Base::poll;
  using Base::raise;
  using Base::result;
  using Base::setCallback_;
  using Base::valid;
  using Base::value;

  SemiFuture& operator=(SemiFuture const&) = delete;
  SemiFuture& operator=(SemiFuture&&) noexcept;
  SemiFuture& operator=(Future<T>&&) noexcept;

  T get() &&;

  [[deprecated("must be rvalue-qualified, e.g., std::move(future).get()")]] T
  get() & = delete;

  T get(Duration dur) &&;

  [[deprecated("must be rvalue-qualified, e.g., std::move(future).get(dur)")]] T
  get(Duration dur) & = delete;

  Try<T> getTry() &&;

  Try<T> getTry(Duration dur) &&;

  SemiFuture<T>& wait() &;

  SemiFuture<T>&& wait() &&;

  bool wait(Duration dur) &&;

  Future<T> via(Executor* executor, int8_t priority = Executor::MID_PRI) &&;

  Future<T> via(
      Executor::KeepAlive<> executor,
      int8_t priority = Executor::MID_PRI) &&;

  template <typename F>
  SemiFuture<typename futures::detail::tryCallableResult<T, F>::value_type>
  defer(F&& func) &&;

  template <typename R, typename... Args>
  auto defer(R (&func)(Args...)) && {
    return std::move(*this).defer(&func);
  }

  template <typename F>
  SemiFuture<typename futures::detail::valueCallableResult<T, F>::value_type>
  deferValue(F&& func) &&;

  template <typename R, typename... Args>
  auto deferValue(R (&func)(Args...)) && {
    return std::move(*this).deferValue(&func);
  }

  template <class ExceptionType, class F>
  SemiFuture<T> deferError(F&& func) &&;

  template <class ExceptionType, class R, class... Args>
  SemiFuture<T> deferError(R (&func)(Args...)) && {
    return std::move(*this).template deferError<ExceptionType>(&func);
  }

  template <class F>
  SemiFuture<T> deferError(F&& func) &&;

  template <class R, class... Args>
  SemiFuture<T> deferError(R (&func)(Args...)) && {
    return std::move(*this).deferError(&func);
  }

  SemiFuture<T> within(Duration dur, Timekeeper* tk = nullptr) && {
    return std::move(*this).within(dur, FutureTimeout(), tk);
  }

  template <class E>
  SemiFuture<T> within(Duration dur, E e, Timekeeper* tk = nullptr) && {
    return this->isReady() ? std::move(*this)
                           : std::move(*this).withinImplementation(dur, e, tk);
  }

  SemiFuture<T> delayed(Duration dur, Timekeeper* tk = nullptr) &&;

  Future<T> toUnsafeFuture() &&;

#if FOLLY_HAS_COROUTINES
  class promise_type {
   public:
    SemiFuture get_return_object() {
      return promise_.getSemiFuture();
    }

    std::experimental::suspend_never initial_suspend() {
      return {};
    }

    std::experimental::suspend_never final_suspend() {
      return {};
    }

    void return_value(const T& value) {
      promise_.setValue(value);
    }

    void return_value(T&& value) {
      promise_.setValue(std::move(value));
    }

    void unhandled_exception() {
      try {
        std::rethrow_exception(std::current_exception());
      } catch (std::exception& e) {
        promise_.setException(exception_wrapper(std::current_exception(), e));
      } catch (...) {
        promise_.setException(exception_wrapper(std::current_exception()));
      }
    }

   private:
    folly::Promise<T> promise_;
  };

  // Customise the co_viaIfAsync() operator so that SemiFuture<T> can be
  // directly awaited within a folly::coro::Task coroutine.
  friend Future<T> co_viaIfAsync(
      folly::Executor* executor,
      SemiFuture<T>&& future) noexcept {
    return std::move(future).via(executor);
  }

#endif

 private:
  friend class Promise<T>;
  template <class>
  friend class futures::detail::FutureBase;
  template <class>
  friend class SemiFuture;
  template <class>
  friend class Future;
  friend folly::Executor::KeepAlive<DeferredExecutor>
  futures::detail::stealDeferredExecutor<T>(SemiFuture&);
  friend DeferredExecutor* futures::detail::getDeferredExecutor<T>(SemiFuture&);

  using Base::setExecutor;
  using Base::throwIfInvalid;
  using typename Base::Core;

  template <class T2>
  friend SemiFuture<T2> makeSemiFuture(Try<T2>);

  explicit SemiFuture(Core* obj) : Base(obj) {}

  explicit SemiFuture(futures::detail::EmptyConstruct) noexcept
      : Base(futures::detail::EmptyConstruct{}) {}

  // Throws FutureInvalid if !this->core_
  DeferredExecutor* getDeferredExecutor() const;

  // Throws FutureInvalid if !this->core_
  folly::Executor::KeepAlive<DeferredExecutor> stealDeferredExecutor() const;

  SemiFuture<T>& wait(Duration dur) &;

  static void releaseDeferredExecutor(Core* core);
};

template <class T>
std::pair<Promise<T>, SemiFuture<T>> makePromiseContract() {
  auto p = Promise<T>();
  auto f = p.getSemiFuture();
  return std::make_pair(std::move(p), std::move(f));
}

template <class T>
class Future : private futures::detail::FutureBase<T> {
 private:
  using Base = futures::detail::FutureBase<T>;

 public:
  using typename Base::value_type;

  template <
      class T2 = T,
      typename = typename std::enable_if<
          !isFuture<typename std::decay<T2>::type>::value &&
          !isSemiFuture<typename std::decay<T2>::type>::value>::type>
  /* implicit */ Future(T2&& val) : Base(std::forward<T2>(val)) {}

  template <class T2 = T>
  /* implicit */ Future(
      typename std::enable_if<std::is_same<Unit, T2>::value>::type* p = nullptr)
      : Base(p) {}

  template <
      class... Args,
      typename std::enable_if<std::is_constructible<T, Args&&...>::value, int>::
          type = 0>
  explicit Future(in_place_t, Args&&... args)
      : Base(in_place, std::forward<Args>(args)...) {}

  Future(Future<T> const&) = delete;
  // movable
  Future(Future<T>&&) noexcept;

  // converting move
  template <
      class T2,
      typename std::enable_if<
          !std::is_same<T, typename std::decay<T2>::type>::value &&
              std::is_constructible<T, T2&&>::value &&
              std::is_convertible<T2&&, T>::value,
          int>::type = 0>
  /* implicit */ Future(Future<T2>&&);
  template <
      class T2,
      typename std::enable_if<
          !std::is_same<T, typename std::decay<T2>::type>::value &&
              std::is_constructible<T, T2&&>::value &&
              !std::is_convertible<T2&&, T>::value,
          int>::type = 0>
  explicit Future(Future<T2>&&);
  template <
      class T2,
      typename std::enable_if<
          !std::is_same<T, typename std::decay<T2>::type>::value &&
              std::is_constructible<T, T2&&>::value,
          int>::type = 0>
  Future& operator=(Future<T2>&&);

  using Base::cancel;
  using Base::getPriority;
  using Base::hasException;
  using Base::hasValue;
  using Base::isReady;
  using Base::poll;
  using Base::raise;
  using Base::result;
  using Base::setCallback_;
  using Base::valid;
  using Base::value;

  static Future<T> makeEmpty();

  // not copyable
  Future& operator=(Future const&) = delete;

  // movable
  Future& operator=(Future&&) noexcept;

  T getVia(DrivableExecutor* e);

  T getVia(TimedDrivableExecutor* e, Duration dur);

  Try<T>& getTryVia(DrivableExecutor* e);

  Try<T>& getTryVia(TimedDrivableExecutor* e, Duration dur);

  template <class F = T>
  typename std::
      enable_if<isFuture<F>::value, Future<typename isFuture<T>::Inner>>::type
      unwrap() &&;

  Future<T> via(Executor* executor, int8_t priority = Executor::MID_PRI) &&;

  Future<T> via(
      Executor::KeepAlive<> executor,
      int8_t priority = Executor::MID_PRI) &&;

  Future<T> via(Executor* executor, int8_t priority = Executor::MID_PRI) &;

  Future<T> via(
      Executor::KeepAlive<> executor,
      int8_t priority = Executor::MID_PRI) &;

  template <typename F, typename R = futures::detail::callableResult<T, F>>
  [[deprecated("ERROR: use thenValue instead")]] typename std::enable_if<
      !is_invocable<F>::value && is_invocable<F, T&&>::value,
      typename R::Return>::type
  then(F&& func) && {
    return std::move(*this).thenValue(std::forward<F>(func));
  }

  template <typename F, typename R = futures::detail::callableResult<T, F>>
  [[deprecated("ERROR: use thenTry instead")]] typename std::enable_if<
      !is_invocable<F, T&&>::value && !is_invocable<F>::value,
      typename R::Return>::type
  then(F&& func) && {
    return std::move(*this).thenTry(std::forward<F>(func));
  }

  template <typename F, typename R = futures::detail::callableResult<T, F>>
  [[deprecated(
      "ERROR: use thenValue with auto&& or folly::Unit parameter instead")]]
  typename std::enable_if<is_invocable<F>::value, typename R::Return>::type
  then(F&& func) && = delete;

  // clang-format off
  template <typename F, typename R = futures::detail::callableResult<T, F>>
  [[deprecated(
    "must be rvalue-qualified, e.g., std::move(future).thenValue(...)")]]
  typename R::Return then(F&& func) & = delete;
  // clang-format on

  template <typename R, typename Caller, typename... Args>
  Future<typename isFuture<R>::Inner> then(
      R (Caller::*func)(Args...),
      Caller* instance) &&;

  // clang-format off
  template <typename R, typename Caller, typename... Args>
  [[deprecated(
      "must be rvalue-qualified, e.g., std::move(future).then(...)")]]
  Future<typename isFuture<R>::Inner>
  then(R (Caller::*func)(Args...), Caller* instance) & = delete;
  // clang-format on

  template <class Arg>
  auto then(Executor* x, Arg&& arg) && {
    auto oldX = this->getExecutor();
    this->setExecutor(x);

    // TODO(T29171940): thenImplementation here is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, Arg&&>;
    return std::move(*this)
        .thenImplementation(std::forward<Arg>(arg), R{})
        .via(oldX);
  }

  template <class R, class Caller, class... Args>
  auto then(Executor* x, R (Caller::*func)(Args...), Caller* instance) && {
    auto oldX = this->getExecutor();
    this->setExecutor(x);

    return std::move(*this).then(func, instance).via(oldX);
  }

  template <class Arg, class... Args>
  [[deprecated(
      "must be rvalue-qualified, e.g., std::move(future).then(...)")]] auto
  then(Executor* x, Arg&& arg, Args&&... args) & = delete;

  template <typename F>
  Future<typename futures::detail::tryCallableResult<T, F>::value_type> thenTry(
      F&& func) &&;

  template <typename R, typename... Args>
  auto thenTry(R (&func)(Args...)) && {
    return std::move(*this).thenTry(&func);
  }

  template <typename F>
  Future<typename futures::detail::valueCallableResult<T, F>::value_type>
  thenValue(F&& func) &&;

  template <typename R, typename... Args>
  auto thenValue(R (&func)(Args...)) && {
    return std::move(*this).thenValue(&func);
  }

  template <class ExceptionType, class F>
  Future<T> thenError(F&& func) &&;

  template <class ExceptionType, class R, class... Args>
  Future<T> thenError(R (&func)(Args...)) && {
    return std::move(*this).template thenError<ExceptionType>(&func);
  }

  template <class F>
  Future<T> thenError(F&& func) &&;

  template <class R, class... Args>
  Future<T> thenError(R (&func)(Args...)) && {
    return std::move(*this).thenError(&func);
  }

  Future<Unit> then() &&;

  // clang-format off
  [[deprecated(
      "must be rvalue-qualified, e.g., std::move(future).thenValue()")]]
  Future<Unit> then() & = delete;
  // clang-format on

  Future<Unit> unit() && {
    return std::move(*this).then();
  }

  template <class F>
  typename std::enable_if<
      !is_invocable<F, exception_wrapper>::value &&
          !futures::detail::Extract<F>::ReturnsFuture::value,
      Future<T>>::type
  onError(F&& func) &&;

  template <class F>
  typename std::enable_if<
      !is_invocable<F, exception_wrapper>::value &&
          futures::detail::Extract<F>::ReturnsFuture::value,
      Future<T>>::type
  onError(F&& func) &&;

  template <class F>
  typename std::enable_if<
      is_invocable<F, exception_wrapper>::value &&
          futures::detail::Extract<F>::ReturnsFuture::value,
      Future<T>>::type
  onError(F&& func) &&;

  template <class F>
  typename std::enable_if<
      is_invocable<F, exception_wrapper>::value &&
          !futures::detail::Extract<F>::ReturnsFuture::value,
      Future<T>>::type
  onError(F&& func) &&;

  // clang-format off
  template <class F>
  [[deprecated("use rvalue-qualified fn, eg, std::move(future).onError(...)")]]
  Future<T> onError(F&& func) & {
    return std::move(*this).onError(std::forward<F>(func));
  }

  template <class F>
  Future<T> ensure(F&& func) &&;
  // clang-format on

  template <class F>
  Future<T> onTimeout(Duration, F&& func, Timekeeper* = nullptr) &&;

  Future<T> within(Duration dur, Timekeeper* tk = nullptr) &&;

  template <class E>
  Future<T> within(Duration dur, E exception, Timekeeper* tk = nullptr) &&;

  Future<T> delayed(Duration, Timekeeper* = nullptr) &&;

  Future<T> delayedUnsafe(Duration, Timekeeper* = nullptr);

  T get() &&;

  [[deprecated("must be rvalue-qualified, e.g., std::move(future).get()")]] T
  get() & = delete;

  T get(Duration dur) &&;

  [[deprecated("must be rvalue-qualified, e.g., std::move(future).get(dur)")]] T
  get(Duration dur) & = delete;

  Try<T>& getTry();

  Future<T>& wait() &;

  Future<T>&& wait() &&;

  Future<T>& wait(Duration dur) &;

  Future<T>&& wait(Duration dur) &&;

  Future<T>& waitVia(DrivableExecutor* e) &;

  Future<T>&& waitVia(DrivableExecutor* e) &&;

  Future<T>& waitVia(TimedDrivableExecutor* e, Duration dur) &;

  Future<T>&& waitVia(TimedDrivableExecutor* e, Duration dur) &&;

  Future<bool> willEqual(Future<T>&);

  template <class F>
  Future<T> filter(F&& predicate) &&;

  template <class I, class F>
  Future<I> reduce(I&& initial, F&& func) &&;

  template <class Callback, class... Callbacks>
  auto thenMulti(Callback&& fn, Callbacks&&... fns) && {
    // thenMulti with two callbacks is just then(a).thenMulti(b, ...)

    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this)
        .thenImplementation(std::forward<Callback>(fn), R{})
        .thenMulti(std::forward<Callbacks>(fns)...);
  }

  template <class Callback>
  auto thenMulti(Callback&& fn) && {
    // thenMulti with one callback is just a then

    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this).thenImplementation(std::forward<Callback>(fn), R{});
  }

  template <class Callback>
  auto thenMulti(Callback&& fn) & {
    return std::move(*this).thenMulti(std::forward<Callback>(fn));
  }

  template <class Callback, class... Callbacks>
  auto
  thenMultiWithExecutor(Executor* x, Callback&& fn, Callbacks&&... fns) && {
    // thenMultiExecutor with two callbacks is
    // via(x).then(a).thenMulti(b, ...).via(oldX)
    auto oldX = this->getExecutor();
    this->setExecutor(x);
    // TODO(T29171940): Switch to thenImplementation here. It is ambiguous
    // as then used to be but that is better than keeping then in the public
    // API.
    using R = futures::detail::callableResult<T, decltype(fn)>;
    return std::move(*this)
        .thenImplementation(std::forward<Callback>(fn), R{})
        .thenMulti(std::forward<Callbacks>(fns)...)
        .via(oldX);
  }

  template <class Callback>
  auto thenMultiWithExecutor(Executor* x, Callback&& fn) && {
    // thenMulti with one callback is just a then with an executor
    return std::move(*this).then(x, std::forward<Callback>(fn));
  }

  SemiFuture<T> semi() && {
    return SemiFuture<T>{std::move(*this)};
  }

#if FOLLY_HAS_COROUTINES

  // Overload needed to customise behaviour of awaiting a Future<T>
  // inside a folly::coro::Task coroutine.
  friend Future<T> co_viaIfAsync(
      folly::Executor* executor,
      Future<T>&& future) noexcept {
    return std::move(future).via(executor);
  }

#endif

 protected:
  friend class Promise<T>;
  template <class>
  friend class futures::detail::FutureBase;
  template <class>
  friend class Future;
  template <class>
  friend class SemiFuture;
  template <class>
  friend class FutureSplitter;

  using Base::setExecutor;
  using Base::throwIfContinued;
  using Base::throwIfInvalid;
  using typename Base::Core;

  explicit Future(Core* obj) : Base(obj) {}

  explicit Future(futures::detail::EmptyConstruct) noexcept
      : Base(futures::detail::EmptyConstruct{}) {}

  template <class T2>
  friend Future<T2> makeFuture(Try<T2>);

  template <class F>
  friend Future<Unit> times(int n, F&& thunk);

  template <class F>
  friend Future<Unit> when(bool p, F&& thunk);

  template <class P, class F>
  friend Future<Unit> whileDo(P&& predicate, F&& thunk);

  template <class FT>
  friend void futures::detail::convertFuture(
      SemiFuture<FT>&& sf,
      Future<FT>& f);
};

class Timekeeper {
 public:
  virtual ~Timekeeper() = default;

  virtual Future<Unit> after(Duration dur) = 0;

  template <class Clock>
  Future<Unit> at(std::chrono::time_point<Clock> when);
};

template <class T>
std::pair<Promise<T>, Future<T>> makePromiseContract(Executor* e) {
  auto p = Promise<T>();
  auto f = p.getSemiFuture().via(e);
  return std::make_pair(std::move(p), std::move(f));
}

} // namespace folly

#if FOLLY_HAS_COROUTINES

namespace folly {
namespace detail {

template <typename T>
class FutureAwaitable {
 public:
  explicit FutureAwaitable(folly::Future<T>&& future) noexcept
      : future_(std::move(future)) {}

  bool await_ready() const {
    return future_.isReady();
  }

  T await_resume() {
    return std::move(future_).value();
  }

  void await_suspend(std::experimental::coroutine_handle<> h) {
    future_.setCallback_([h](Try<T>&&) mutable {
      // Don't std::move() so the try is left in the future for await_resume()
      h.resume();
    });
  }

 private:
  folly::Future<T> future_;
};

} // namespace detail

template <typename T>
inline detail::FutureAwaitable<T>
/* implicit */ operator co_await(Future<T>&& future) noexcept {
  return detail::FutureAwaitable<T>(std::move(future));
}

namespace coro {

template <typename Awaitable>
inline auto toSemiFuture(Awaitable awaitable) -> std::enable_if_t<
    !std::is_void<folly::coro::await_result_t<Awaitable>>::value,
    SemiFuture<await_result_t<Awaitable>>> {
  co_return co_await static_cast<Awaitable&&>(awaitable);
}

template <typename Awaitable>
inline auto toSemiFuture(Awaitable awaitable) -> std::enable_if_t<
    std::is_void<folly::coro::await_result_t<Awaitable>>::value,
    SemiFuture<Unit>> {
  co_await static_cast<Awaitable&&>(awaitable);
  co_return Unit{};
}

} // namespace coro

} // namespace folly
#endif

#include <folly/futures/Future-inl.h>