Add async_result support to go().

asio/include/asio/detail/variadic_templates.hpp

diff --git a/asio/include/asio/detail/variadic_templates.hpp b/asio/include/asio/detail/variadic_templates.hpp
index a8ac797..2c1f533 100644
--- a/asio/include/asio/detail/variadic_templates.hpp
+++ b/asio/include/asio/detail/variadic_templates.hpp
@@ -48,6 +48,20 @@
 # define ASIO_VARIADIC_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4
 # define ASIO_VARIADIC_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5
 
+# define ASIO_VARIADIC_CONSTREF_PARAMS(n) \
+  ASIO_VARIADIC_CONSTREF_PARAMS_##n
+
+# define ASIO_VARIADIC_CONSTREF_PARAMS_1 \
+  const T1& x1
+# define ASIO_VARIADIC_CONSTREF_PARAMS_2 \
+  const T1& x1, const T2& x2
+# define ASIO_VARIADIC_CONSTREF_PARAMS_3 \
+  const T1& x1, const T2& x2, const T3& x3
+# define ASIO_VARIADIC_CONSTREF_PARAMS_4 \
+  const T1& x1, const T2& x2, const T3& x3, const T4& x4
+# define ASIO_VARIADIC_CONSTREF_PARAMS_5 \
+  const T1& x1, const T2& x2, const T3& x3, const T4& x4, const T5& x5
+
 # define ASIO_VARIADIC_ARGS(n) ASIO_VARIADIC_ARGS_##n
 
 # define ASIO_VARIADIC_ARGS_1 x1

asio/include/asio/go.hpp

diff --git a/asio/include/asio/go.hpp b/asio/include/asio/go.hpp
index ce4a2f7..1346964 100644
--- a/asio/include/asio/go.hpp
+++ b/asio/include/asio/go.hpp
@@ -17,16 +17,33 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/coroutine.hpp"
+#include "asio/detail/variadic_templates.hpp"
 #include "asio/detail/wrapped_handler.hpp"
 #include "asio/io_service.hpp"
 #include "asio/strand.hpp"
 
+#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+# include "asio/detail/variadic_templates.hpp"
+
+// A macro that should expand to:
+//   template <typename T1, ..., typename Tn>
+//   void complete(const T1& x1, ..., const Tn& xn);
+// This macro should only persist within this file.
+
+# define ASIO_PRIVATE_COMPLETE_DECL(n) \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void complete(ASIO_VARIADIC_CONSTREF_PARAMS(n)); \
+  /**/
+
+#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
 namespace detail {
   
-template <typename Handler> class stackless_impl_base;
+template <typename Handler, typename Signature> class stackless_impl_base;
 
 } // namespace detail
 
@@ -47,11 +64,11 @@
  *   }
  * } @endcode
  *
- * The initiating function (async_read_some in the above example) suspends the
- * current coroutine. The coroutine is resumed when the asynchronous operation
- * completes.
+ * The initiating function (@c async_read_some in the above example) suspends
+ * the current coroutine. The coroutine is resumed when the asynchronous
+ * operation completes.
  */
-template <typename Handler>
+template <typename Handler, typename Signature = void ()>
 class basic_stackless_context
 {
 public:
@@ -84,10 +101,31 @@
     return tmp;
   }
 
+  /// Invoke the completion handler with the specified arguments.
+  /**
+   * This function is used to invoke the coroutine's associated completion
+   * handler. It should be called at most once, immediately prior to the
+   * termination of the coroutine. Additional calls will be ignored.
+   *
+   * For completion handlers with the signature <tt>void()</tt>, and if @c
+   * complete() is not explicitly called, the completion handler will be
+   * automatically invoked after coroutine termination.
+   */
+#if defined(GENERATING_DOCUMENTATION) \
+  || defined(ASIO_HAS_VARIADIC_TEMPLATES)
+  template <typename... T>
+  void complete(T&&... args);
+#else // defined(GENERATING_DOCUMENTATION)
+      //   || defined(ASIO_HAS_VARIADIC_TEMPLATES)
+  void complete();
+  ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_COMPLETE_DECL)
+#endif // defined(GENERATING_DOCUMENTATION)
+       //   || defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
 #if defined(GENERATING_DOCUMENTATION)
 private:
 #endif // defined(GENERATING_DOCUMENTATION)
-  detail::stackless_impl_base<Handler>** impl_;
+  detail::stackless_impl_base<Handler, Signature>** impl_;
   asio::error_code* ec_;
 };
 
@@ -97,7 +135,7 @@
 #else // defined(GENERATING_DOCUMENTATION)
 typedef basic_stackless_context<
   detail::wrapped_handler<
-    io_service::strand, void(*)(),
+    io_service::strand, void (*)(),
     detail::is_continuation_if_running> > stackless_context;
 #endif // defined(GENERATING_DOCUMENTATION)
 
@@ -143,21 +181,40 @@
  */
 /*@{*/
 
-/// Start a new stackless coroutine, calling the specified handler when it
-/// completes.
+/// Start a new stackless coroutine with an associated completion handler.
 /**
  * This function is used to launch a new coroutine.
  *
- * @param handler A handler to be called when the coroutine exits. More
+ * @param handler The handler associated with the coroutine. The handler may be
+ * explicitly called via the context's @c complete() function, but will be
+ * invoked automatically after coroutine termination if not called first. More
  * importantly, the handler provides an execution context (via the the handler
  * invocation hook) for the coroutine. The handler must have the signature:
  * @code void handler(); @endcode
  *
  * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_stackless_context<Handler> yield); @endcode
+ * @code void function(basic_stackless_context<Handler> c); @endcode
  */
 template <typename Handler, typename Function>
-void go(ASIO_MOVE_ARG(Handler) handler,
+ASIO_INITFN_RESULT_TYPE(Handler, void ())
+go(ASIO_MOVE_ARG(Handler) handler,
+    ASIO_MOVE_ARG(Function) function);
+
+/// Start a new stackless coroutine with an associated completion handler.
+/**
+ * This function is used to launch a new coroutine.
+ *
+ * @param handler The handler associated with the coroutine. The handler may be
+ * explicitly called via the context's @c complete() function. Furthermore, the
+ * handler provides an execution context (via the the handler invocation hook)
+ * for the coroutine.
+ *
+ * @param function The coroutine function. The function must have the signature:
+ * @code void function(basic_stackless_context<Handler, Signature> c); @endcode
+ */
+template <typename Signature, typename Handler, typename Function>
+ASIO_INITFN_RESULT_TYPE(Handler, Signature)
+go(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function);
 
 /// Start a new stackless coroutine, inheriting the execution context of another.
@@ -212,6 +269,10 @@
 
 #include "asio/detail/pop_options.hpp"
 
+#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
+# undef ASIO_PRIVATE_COMPLETE_DECL
+#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
 #include "asio/impl/go.hpp"
 
 #endif // ASIO_GO_HPP

asio/include/asio/impl/go.hpp

diff --git a/asio/include/asio/impl/go.hpp b/asio/include/asio/impl/go.hpp
index 45ac9b9..824922e 100644
--- a/asio/include/asio/impl/go.hpp
+++ b/asio/include/asio/impl/go.hpp
@@ -29,20 +29,21 @@
 namespace asio {
 namespace detail {
 
-  template <typename Handler>
+  template <typename Handler, typename Signature>
   class stackless_impl_base
   {
   protected:
     template <typename Handler1>
     explicit stackless_impl_base(ASIO_MOVE_ARG(Handler1) handler,
-        void (*resume_fn)(const basic_stackless_context<Handler>&),
+        void (*resume_fn)(const basic_stackless_context<Handler, Signature>&),
         void (*destroy_fn)(stackless_impl_base*))
       : handler_(ASIO_MOVE_CAST(Handler1)(handler)),
         ref_count_(1),
         result_ec_(&throw_ec_),
         result_value_(0),
         resume_(resume_fn),
-        destroy_(destroy_fn)
+        destroy_(destroy_fn),
+        completed_(false)
     {
     }
 
@@ -53,37 +54,40 @@
     static void resume(stackless_impl_base*& impl);
 
   //private:
-    Handler handler_;
+    typename handler_type<Handler, Signature>::type handler_;
     asio::detail::atomic_count ref_count_;
     asio::coroutine coroutine_;
     asio::error_code throw_ec_;
     asio::error_code* result_ec_;
     void* result_value_;
-    void (*resume_)(const basic_stackless_context<Handler>&);
+    void (*resume_)(const basic_stackless_context<Handler, Signature>&);
     void (*destroy_)(stackless_impl_base*);
+    bool completed_;
   };
 
-  template <typename Handler>
-  stackless_impl_base<Handler>* stackless_impl_base<Handler>::add_ref(
-      stackless_impl_base<Handler>* impl)
+  template <typename Handler, typename Signature>
+  stackless_impl_base<Handler, Signature>*
+  stackless_impl_base<Handler, Signature>::add_ref(
+      stackless_impl_base<Handler, Signature>* impl)
   {
     if (impl)
       ++impl->ref_count_;
     return impl;
   }
 
-  template <typename Handler>
-  inline stackless_impl_base<Handler>* stackless_impl_base<Handler>::move_ref(
-      stackless_impl_base<Handler>*& impl)
+  template <typename Handler, typename Signature>
+  inline stackless_impl_base<Handler, Signature>*
+  stackless_impl_base<Handler, Signature>::move_ref(
+      stackless_impl_base<Handler, Signature>*& impl)
   {
     stackless_impl_base* tmp = impl;
     impl = 0;
     return tmp;
   }
 
-  template <typename Handler>
-  void stackless_impl_base<Handler>::release_ref(
-      stackless_impl_base<Handler>* impl)
+  template <typename Handler, typename Signature>
+  void stackless_impl_base<Handler, Signature>::release_ref(
+      stackless_impl_base<Handler, Signature>* impl)
   {
     if (impl)
     {
@@ -92,26 +96,45 @@
     }
   }
 
-  template <typename Handler>
-  void stackless_impl_base<Handler>::resume(
-      stackless_impl_base<Handler>*& impl)
+  template <typename Signature>
+  struct call_completed_handler
+  {
+    template <typename Handler>
+    static void call(Handler&) {}
+  };
+
+  template <>
+  struct call_completed_handler<void ()>
+  {
+    template <typename Handler>
+    static void call(Handler& h) { h(); }
+  };
+
+  template <typename Handler, typename Signature>
+  void stackless_impl_base<Handler, Signature>::resume(
+      stackless_impl_base<Handler, Signature>*& impl)
   {
     impl->result_value_ = 0;
-    const basic_stackless_context<Handler> ctx = { &impl, &impl->throw_ec_ };
+    basic_stackless_context<Handler, Signature> ctx
+      = { &impl, &impl->throw_ec_ };
     impl->resume_(ctx);
-    if (impl && impl->coroutine_.is_complete())
-      impl->handler_();
+
+    if (impl && impl->coroutine_.is_complete() && !impl->completed_)
+    {
+      impl->completed_ = true;
+      call_completed_handler<Signature>::call(impl->handler_);
+    }
   }
 
-  template <typename Handler, typename Function>
+  template <typename Handler, typename Signature, typename Function>
   class stackless_impl :
-    public stackless_impl_base<Handler>
+    public stackless_impl_base<Handler, Signature>
   {
   public:
     template <typename Handler1, typename Function1>
     stackless_impl(ASIO_MOVE_ARG(Handler1) handler,
         ASIO_MOVE_ARG(Function1) function)
-      : stackless_impl_base<Handler>(
+      : stackless_impl_base<Handler, Signature>(
           ASIO_MOVE_CAST(Handler1)(handler),
           &stackless_impl::do_resume,
           &stackless_impl::do_destroy),
@@ -120,13 +143,14 @@
     }
 
   private:
-    static void do_resume(const basic_stackless_context<Handler>& ctx)
+    static void do_resume(
+        const basic_stackless_context<Handler, Signature>& ctx)
     {
-      stackless_impl_base<Handler>* base = *ctx.impl_;
+      stackless_impl_base<Handler, Signature>* base = *ctx.impl_;
       static_cast<stackless_impl*>(base)->function_(ctx);
     }
 
-    static void do_destroy(stackless_impl_base<Handler>* impl)
+    static void do_destroy(stackless_impl_base<Handler, Signature>* impl)
     {
       delete static_cast<stackless_impl*>(impl);
     }
@@ -134,31 +158,31 @@
     Function function_;
   };
 
-  template <typename Handler, typename T>
+  template <typename Handler, typename Signature, typename T>
   class stackless_handler
   {
   public:
-    stackless_handler(const basic_stackless_context<Handler>& ctx)
-      : impl_(stackless_impl_base<Handler>::move_ref(*ctx.impl_))
+    stackless_handler(const basic_stackless_context<Handler, Signature>& ctx)
+      : impl_(stackless_impl_base<Handler, Signature>::move_ref(*ctx.impl_))
     {
       impl_->result_ec_ = ctx.ec_;
     }
 
     stackless_handler(const stackless_handler& other)
-      : impl_(stackless_impl_base<Handler>::add_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::add_ref(other.impl_))
     {
     }
 
 #if defined(ASIO_HAS_MOVE)
     stackless_handler(stackless_handler&& other)
-      : impl_(stackless_impl_base<Handler>::move_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::move_ref(other.impl_))
     {
     }
 #endif // defined(ASIO_HAS_MOVE)
 
     ~stackless_handler()
     {
-      stackless_impl_base<Handler>::release_ref(impl_);
+      stackless_impl_base<Handler, Signature>::release_ref(impl_);
     }
 
     void operator()(T value)
@@ -166,7 +190,7 @@
       *impl_->result_ec_ = asio::error_code();
       if (impl_->result_value_)
         *static_cast<T*>(impl_->result_value_) = value;
-      stackless_impl_base<Handler>::resume(impl_);
+      stackless_impl_base<Handler, Signature>::resume(impl_);
     }
 
     void operator()(asio::error_code ec, T value)
@@ -174,130 +198,139 @@
       *impl_->result_ec_ = ec;
       if (impl_->result_value_)
         *static_cast<T*>(impl_->result_value_) = value;
-      stackless_impl_base<Handler>::resume(impl_);
+      stackless_impl_base<Handler, Signature>::resume(impl_);
     }
 
   //private:
-    stackless_impl_base<Handler>* impl_;
+    stackless_impl_base<Handler, Signature>* impl_;
+
+  private:
+    stackless_handler& operator=(const stackless_handler&);
   };
 
-  template <typename Handler>
-  class stackless_handler<Handler, void>
+  template <typename Handler, typename Signature>
+  class stackless_handler<Handler, Signature, void>
   {
   public:
-    stackless_handler(const basic_stackless_context<Handler>& ctx)
-      : impl_(stackless_impl_base<Handler>::move_ref(*ctx.impl_))
+    stackless_handler(const basic_stackless_context<Handler, Signature>& ctx)
+      : impl_(stackless_impl_base<Handler, Signature>::move_ref(*ctx.impl_))
     {
       impl_->result_ec_ = ctx.ec_;
     }
 
     stackless_handler(const stackless_handler& other)
-      : impl_(stackless_impl_base<Handler>::add_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::add_ref(other.impl_))
     {
     }
 
 #if defined(ASIO_HAS_MOVE)
     stackless_handler(stackless_handler&& other)
-      : impl_(stackless_impl_base<Handler>::move_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::move_ref(other.impl_))
     {
     }
 #endif // defined(ASIO_HAS_MOVE)
 
     ~stackless_handler()
     {
-      stackless_impl_base<Handler>::release_ref(impl_);
+      stackless_impl_base<Handler, Signature>::release_ref(impl_);
     }
 
     void operator()()
     {
       *impl_->result_ec_ = asio::error_code();
-      stackless_impl_base<Handler>::resume(impl_);
+      stackless_impl_base<Handler, Signature>::resume(impl_);
     }
 
     void operator()(asio::error_code ec)
     {
       *impl_->result_ec_ = ec;
-      stackless_impl_base<Handler>::resume(impl_);
+      stackless_impl_base<Handler, Signature>::resume(impl_);
     }
 
   //private:
-    stackless_impl_base<Handler>* impl_;
+    stackless_impl_base<Handler, Signature>* impl_;
+
+  private:
+    stackless_handler& operator=(const stackless_handler&);
   };
 
-  template <typename Handler, typename T>
+  template <typename Handler, typename Signature, typename T>
   inline void* asio_handler_allocate(std::size_t size,
-      stackless_handler<Handler, T>* this_handler)
+      stackless_handler<Handler, Signature, T>* this_handler)
   {
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->impl_->handler_);
   }
 
-  template <typename Handler, typename T>
+  template <typename Handler, typename Signature, typename T>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      stackless_handler<Handler, T>* this_handler)
+      stackless_handler<Handler, Signature, T>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->impl_->handler_);
   }
 
-  template <typename Handler, typename T>
+  template <typename Handler, typename Signature, typename T>
   inline bool asio_handler_is_continuation(
-      stackless_handler<Handler, T>*)
+      stackless_handler<Handler, Signature, T>*)
   {
     return true;
   }
 
-  template <typename Function, typename Handler, typename T>
+  template <typename Function, typename Handler, typename Signature, typename T>
   inline void asio_handler_invoke(Function& function,
-      stackless_handler<Handler, T>* this_handler)
+      stackless_handler<Handler, Signature, T>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->impl_->handler_);
   }
 
-  template <typename Function, typename Handler, typename T>
+  template <typename Function, typename Handler, typename Signature, typename T>
   inline void asio_handler_invoke(const Function& function,
-      stackless_handler<Handler, T>* this_handler)
+      stackless_handler<Handler, Signature, T>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->impl_->handler_);
   }
 
-  template <typename Handler, typename Function>
+  template <typename Handler, typename Signature, typename Function>
   struct go_helper
   {
     template <typename Handler1, typename Function1>
     go_helper(ASIO_MOVE_ARG(Handler1) handler,
         ASIO_MOVE_ARG(Function1) function)
-      : impl_(new stackless_impl<Handler, Function>(
+      : impl_(new stackless_impl<Handler, Signature, Function>(
             ASIO_MOVE_CAST(Handler1)(handler),
             ASIO_MOVE_CAST(Function1)(function)))
     {
     }
 
     go_helper(const go_helper& other)
-      : impl_(stackless_impl_base<Handler>::add_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::add_ref(other.impl_))
     {
     }
 
 #if defined(ASIO_HAS_MOVE)
     go_helper(go_helper&& other)
-      : impl_(stackless_impl_base<Handler>::move_ref(other.impl_))
+      : impl_(stackless_impl_base<Handler, Signature>::move_ref(other.impl_))
     {
     }
 #endif // defined(ASIO_HAS_MOVE)
 
     ~go_helper()
     {
-      stackless_impl_base<Handler>::release_ref(impl_);
+      stackless_impl_base<Handler, Signature>::release_ref(impl_);
     }
 
     void operator()()
     {
-      stackless_impl_base<Handler>::resume(impl_);
+      stackless_impl_base<Handler, Signature>::resume(impl_);
     }
 
-    stackless_impl_base<Handler>* impl_;
+    stackless_impl_base<Handler, Signature>* impl_;
+
+  private:
+    go_helper& operator=(const go_helper&);
   };
 
   inline void default_go_handler() {}
@@ -306,39 +339,42 @@
 
 #if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Handler, typename ReturnType>
-struct handler_type<basic_stackless_context<Handler>, ReturnType()>
+template <typename Handler, typename Signature, typename ReturnType>
+struct handler_type<basic_stackless_context<Handler, Signature>, ReturnType()>
 {
-  typedef detail::stackless_handler<Handler, void> type;
+  typedef detail::stackless_handler<Handler, Signature, void> type;
 };
 
-template <typename Handler, typename ReturnType, typename Arg1>
-struct handler_type<basic_stackless_context<Handler>, ReturnType(Arg1)>
+template <typename Handler, typename Signature,
+    typename ReturnType, typename Arg1>
+struct handler_type<basic_stackless_context<Handler, Signature>,
+    ReturnType(Arg1)>
 {
-  typedef detail::stackless_handler<Handler, Arg1> type;
+  typedef detail::stackless_handler<Handler, Signature, Arg1> type;
 };
 
-template <typename Handler, typename ReturnType>
-struct handler_type<basic_stackless_context<Handler>,
+template <typename Handler, typename Signature, typename ReturnType>
+struct handler_type<basic_stackless_context<Handler, Signature>,
     ReturnType(asio::error_code)>
 {
-  typedef detail::stackless_handler<Handler, void> type;
+  typedef detail::stackless_handler<Handler, Signature, void> type;
 };
 
-template <typename Handler, typename ReturnType, typename Arg2>
-struct handler_type<basic_stackless_context<Handler>,
+template <typename Handler, typename Signature,
+    typename ReturnType, typename Arg2>
+struct handler_type<basic_stackless_context<Handler, Signature>,
     ReturnType(asio::error_code, Arg2)>
 {
-  typedef detail::stackless_handler<Handler, Arg2> type;
+  typedef detail::stackless_handler<Handler, Signature, Arg2> type;
 };
 
-template <typename Handler, typename T>
-class async_result<detail::stackless_handler<Handler, T> >
+template <typename Handler, typename Signature, typename T>
+class async_result<detail::stackless_handler<Handler, Signature, T> >
 {
 public:
   typedef awaitable<T> type;
 
-  explicit async_result(detail::stackless_handler<Handler, T>&)
+  explicit async_result(detail::stackless_handler<Handler, Signature, T>&)
   {
   }
 
@@ -348,65 +384,161 @@
   }
 };
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline coroutine& get_coroutine(
-    basic_stackless_context<Handler>& c)
+    basic_stackless_context<Handler, Signature>& c)
 {
   return (*c.impl_)->coroutine_;
 }
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline coroutine& get_coroutine(
-    basic_stackless_context<Handler>* c)
+    basic_stackless_context<Handler, Signature>* c)
 {
   return (*c->impl_)->coroutine_;
 }
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline const asio::error_code* get_coroutine_error(
-    basic_stackless_context<Handler>& c)
+    basic_stackless_context<Handler, Signature>& c)
 {
   return &(*c.impl_)->throw_ec_;
 }
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline const asio::error_code* get_coroutine_error(
-    basic_stackless_context<Handler>* c)
+    basic_stackless_context<Handler, Signature>* c)
 {
   return &(*c->impl_)->throw_ec_;
 }
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline void** get_coroutine_async_result(
-    basic_stackless_context<Handler>& c)
+    basic_stackless_context<Handler, Signature>& c)
 {
   return &(*c.impl_)->result_value_;
 }
 
-template <typename Handler>
+template <typename Handler, typename Signature>
 inline void** get_coroutine_async_result(
-    basic_stackless_context<Handler>* c)
+    basic_stackless_context<Handler, Signature>* c)
 {
   return &(*c->impl_)->result_value_;
 }
 
+#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Handler, typename Signature>
+template <typename... T>
+void basic_stackless_context<Handler, Signature>::complete(T&&... args)
+{
+  if (!(*impl_)->completed_)
+  {
+    (*impl_)->completed_ = true;
+    (*impl_)->handler_(static_cast<T&&>(args)...);
+  }
+}
+
+#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename Handler, typename Signature>
+void basic_stackless_context<Handler, Signature>::complete()
+{
+  if (!(*impl_)->completed_)
+  {
+    (*impl_)->completed_ = true;
+    (*impl_)->handler_();
+  }
+}
+
+// A macro that should expand to:
+//   template <typename Handler, typename Signature>
+//   template <typename T1, ..., typename Tn>
+//   void basic_stackless_context<Handler, Signature>::complete(
+//       const T1& x1, ..., const Tn& xn)
+//   {
+//     if (!(*impl_)->completed_)
+//     {
+//       (*impl_)->completed_ = true;
+//       (*impl_)->handler_(x1, ..., xn);
+//     }
+//   }
+// This macro should only persist within this file.
+
+# define ASIO_PRIVATE_COMPLETE_DEF(n) \
+  template <typename Handler, typename Signature> \
+  template <ASIO_VARIADIC_TPARAMS(n)> \
+  void basic_stackless_context<Handler, Signature>::complete( \
+      ASIO_VARIADIC_CONSTREF_PARAMS(n)) \
+  { \
+    if (!(*impl_)->completed_) \
+    { \
+      (*impl_)->completed_ = true; \
+      (*impl_)->handler_(ASIO_VARIADIC_ARGS(n)); \
+    } \
+  } \
+  /**/
+
+ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_COMPLETE_DEF)
+
+# undef ASIO_PRIVATE_COMPLETE_DEF
+
+#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
+
 template <typename Handler, typename Function>
-void go(ASIO_MOVE_ARG(Handler) handler,
+ASIO_INITFN_RESULT_TYPE(Handler, void ())
+go(ASIO_MOVE_ARG(Handler) handler,
     ASIO_MOVE_ARG(Function) function)
 {
-  typedef typename handler_type<Handler, void()>::type
-      real_handler_type;
+  typedef typename remove_const<
+    typename remove_reference<Handler>::type>::type
+      passed_handler_type;
+
+  typedef typename handler_type<
+    Handler, void ()>::type real_handler_type;
 
   typedef typename remove_const<
     typename remove_reference<Function>::type>::type
       function_type;
 
-  detail::go_helper<real_handler_type, function_type> helper(
+  detail::go_helper<passed_handler_type, void (), function_type> helper(
       ASIO_MOVE_CAST(Handler)(handler),
       ASIO_MOVE_CAST(Function)(function));
 
+  async_result<real_handler_type> result(helper.impl_->handler_);
+
   asio_handler_invoke_helpers::invoke(
       helper, helper.impl_->handler_);
+
+  return result.get();
+}
+
+template <typename Signature, typename Handler, typename Function>
+ASIO_INITFN_RESULT_TYPE(Handler, Signature)
+go(ASIO_MOVE_ARG(Handler) handler,
+    ASIO_MOVE_ARG(Function) function)
+{
+  typedef typename remove_const<
+    typename remove_reference<Handler>::type>::type
+      passed_handler_type;
+
+  typedef typename handler_type<
+    Handler, Signature>::type real_handler_type;
+
+  typedef typename remove_const<
+    typename remove_reference<Function>::type>::type
+      function_type;
+
+  detail::go_helper<passed_handler_type, Signature, function_type> helper(
+      ASIO_MOVE_CAST(Handler)(handler),
+      ASIO_MOVE_CAST(Function)(function));
+
+  async_result<real_handler_type> result(helper.impl_->handler_);
+
+  asio_handler_invoke_helpers::invoke(
+      helper, helper.impl_->handler_);
+
+  return result.get();
 }
 
 template <typename Handler, typename Function>