how future made avaitable

This is some information of internal coroutinea

awaiter-co_wait as operator on future and traits into coroutine
struct future_awaiter
{
 future<T>& _f;
 bool await_ready() {
  _f.then([ch]() {});
  return _f.is_ready();
 }
 void await_suspend(coroutine_handle<> ch)
 {
  _f.then([ch]() {ch.resume(); })
 }
 auto await_resume() { return _f.get(); }
};

template<typename T>
future_awaiter<T> operator co_await(future<T>& value) // transform future=>awaitable
{
 return future_awaiter<T>(value);
};

 // make future a coroutine type by specialization
 template<typename T, typename... Arguments>
 struct coroutine_traits<future<T>, Arguments...>
 {
  struct promise_type
  {
   promise<T> _promise;
   future<T> get_return_object() { return _promise.get_future(); }
   auto initialize_suspend() { return suspend_never{}; }
   auto final_suspend() { return suspend_never{}; }
   template<typename U>
   void return_value(U&& value) { _promise.set_value(std::forward<U>(value)); }
   void set_exception(std::exception_ptr ex) { _promise.set_exception(std::move(ex)); }
  };
 };