Harmonize concepts and identifiers with net-ts (API Change):

fix #321

This synchronizes identifier names and some implementation details
with the Networking-TS document and reference implementation.
The following interfaces have changed:

* async_completion
* is_buffer_sequence (removed)
* is_const_buffer_sequence (was is_ConstBufferSequence)
* is_dynamic_buffer (was is_DynamicBuffer)
* is_mutable_buffer_sequence (was is_MutableBufferSequence)
* async_result (new)
* BEAST_HANDLER_TYPE macro (new)
* BEAST_INITFN_RESULT_TYPE macro (new)

Filename changes:

* async_result.hpp (was async_completion.hpp)

CHANGELOG.md

@@ -20,6 +20,7 @@ API Changes:
 * Rename to flat_buffer, basic_flat_buffer
 * Rename to static_buffer, static_buffer_n
 * Rename to buffered_read_stream
+* Harmonize concepts and identifiers with net-ts
 
 --------------------------------------------------------------------------------
 

doc/quickref.xml

@@ -152,6 +152,7 @@
           <bridgehead renderas="sect3">Classes</bridgehead>
           <simplelist type="vert" columns="1">
             <member><link linkend="beast.ref.async_completion">async_completion</link></member>
+            <member><link linkend="beast.ref.async_result">async_result</link></member>
             <member><link linkend="beast.ref.basic_flat_buffer">basic_flat_buffer</link></member>
             <member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member>
             <member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member>
@@ -183,6 +184,11 @@
             <member><link linkend="beast.ref.prepare_buffers">prepare_buffers</link></member>
             <member><link linkend="beast.ref.system_category">system_category</link></member>
           </simplelist>
+          <bridgehead renderas="sect3">Macros</bridgehead>
+          <simplelist type="vert" columns="1">
+            <member><link linkend="beast.ref.BEAST_HANDLER_TYPE">BEAST_HANDLER_TYPE</link></member>
+            <member><link linkend="beast.ref.BEAST_INITFN_RESULT_TYPE">BEAST_INITFN_RESULT_TYPE</link></member>
+          </simplelist>
         </entry>
         <entry valign="top">
           <bridgehead renderas="sect3">Type Traits</bridgehead>
@@ -190,11 +196,10 @@
             <member><link linkend="beast.ref.is_AsyncReadStream">is_AsyncReadStream</link></member>
             <member><link linkend="beast.ref.is_AsyncWriteStream">is_AsyncWriteStream</link></member>
             <member><link linkend="beast.ref.is_AsyncStream">is_AsyncStream</link></member>
-            <member><link linkend="beast.ref.is_BufferSequence">is_BufferSequence</link></member>
             <member><link linkend="beast.ref.is_CompletionHandler">is_CompletionHandler</link></member>
-            <member><link linkend="beast.ref.is_ConstBufferSequence">is_ConstBufferSequence</link></member>
+            <member><link linkend="beast.ref.is_const_buffer_sequence">is_const_buffer_sequence</link></member>
-            <member><link linkend="beast.ref.is_DynamicBuffer">is_DynamicBuffer</link></member>
+            <member><link linkend="beast.ref.is_dynamic_buffer">is_dynamic_buffer</link></member>
-            <member><link linkend="beast.ref.is_MutableBufferSequence">is_MutableBufferSequence</link></member>
+            <member><link linkend="beast.ref.is_mutable_buffer_sequence">is_mutable_buffer_sequence</link></member>
             <member><link linkend="beast.ref.is_SyncReadStream">is_SyncReadStream</link></member>
             <member><link linkend="beast.ref.is_SyncStream">is_SyncStream</link></member>
             <member><link linkend="beast.ref.is_SyncWriteStream">is_SyncWriteStream</link></member>

doc/source.dox

@@ -282,7 +282,11 @@ EXPAND_ONLY_PREDEF     = YES
 SEARCH_INCLUDES        = YES
 INCLUDE_PATH           = ../
 INCLUDE_FILE_PATTERNS  =
-PREDEFINED             = BEAST_DOXYGEN
+
+PREDEFINED             = \
+                        BEAST_DOXYGEN \
+                        BEAST_INITFN_RESULT_TYPE(t,a)=void_or_deduced
+
 EXPAND_AS_DEFINED      =
 SKIP_FUNCTION_MACROS   = YES
 

extras/beast/test/fail_stream.hpp

@@ -8,7 +8,7 @@
 #ifndef BEAST_TEST_FAIL_STREAM_HPP
 #define BEAST_TEST_FAIL_STREAM_HPP
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/error.hpp>
 #include <beast/core/detail/get_lowest_layer.hpp>
@@ -103,20 +103,19 @@ public:
     }
 
     template<class MutableBufferSequence, class ReadHandler>
-    typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(
-        ReadHandler, void(error_code)>::result_type
+        ReadHandler, void(error_code, std::size_t))
     async_read_some(MutableBufferSequence const& buffers,
         ReadHandler&& handler)
     {
         error_code ec;
         if(pfc_->fail(ec))
         {
-            async_completion<
+            async_completion<ReadHandler,
-                ReadHandler, void(error_code, std::size_t)
+                void(error_code, std::size_t)> init{handler};
-                    > completion{handler};
             next_layer_.get_io_service().post(
-                bind_handler(completion.handler, ec, 0));
+                bind_handler(init.completion_handler, ec, 0));
-            return completion.result.get();
+            return init.result.get();
         }
         return next_layer_.async_read_some(buffers,
             std::forward<ReadHandler>(handler));
@@ -140,20 +139,19 @@ public:
     }
 
     template<class ConstBufferSequence, class WriteHandler>
-    typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(
-        WriteHandler, void(error_code)>::result_type
+        WriteHandler, void(error_code, std::size_t))
     async_write_some(ConstBufferSequence const& buffers,
         WriteHandler&& handler)
     {
         error_code ec;
         if(pfc_->fail(ec))
         {
-            async_completion<
+            async_completion<WriteHandler,
-                WriteHandler, void(error_code, std::size_t)
+                void(error_code, std::size_t)> init{handler};
-                    > completion{handler};
             next_layer_.get_io_service().post(
-                bind_handler(completion.handler, ec, 0));
+                bind_handler(init.completion_handler, ec, 0));
-            return completion.result.get();
+            return init.result.get();
         }
         return next_layer_.async_write_some(buffers,
             std::forward<WriteHandler>(handler));

extras/beast/test/string_iostream.hpp

@@ -8,7 +8,7 @@
 #ifndef BEAST_TEST_STRING_IOSTREAM_HPP
 #define BEAST_TEST_STRING_IOSTREAM_HPP
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/error.hpp>
 #include <beast/core/prepare_buffer.hpp>
@@ -78,8 +78,8 @@ public:
     }
 
     template<class MutableBufferSequence, class ReadHandler>
-    typename async_completion<ReadHandler,
+    BEAST_INITFN_RESULT_TYPE(
-        void(error_code, std::size_t)>::result_type
+        ReadHandler, void(error_code, std::size_t))
     async_read_some(MutableBufferSequence const& buffers,
         ReadHandler&& handler)
     {
@@ -91,10 +91,10 @@ public:
         else
             ec = boost::asio::error::eof;
         async_completion<ReadHandler,
-            void(error_code, std::size_t)> completion{handler};
+            void(error_code, std::size_t)> init{handler};
         ios_.post(bind_handler(
-            completion.handler, ec, n));
+            init.completion_handler, ec, n));
-        return completion.result.get();
+        return init.result.get();
     }
 
     template<class ConstBufferSequence>
@@ -124,19 +124,18 @@ public:
     }
 
     template<class ConstBufferSequence, class WriteHandler>
-    typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(
-        WriteHandler, void(error_code)>::result_type
+        WriteHandler, void(error_code, std::size_t))
     async_write_some(ConstBufferSequence const& buffers,
         WriteHandler&& handler)
     {
         error_code ec;
         auto const bytes_transferred = write_some(buffers, ec);
-        async_completion<
+        async_completion<WriteHandler,
-            WriteHandler, void(error_code, std::size_t)
+            void(error_code, std::size_t)> init{handler};
-                > completion{handler};
         get_io_service().post(
-            bind_handler(completion.handler, ec, bytes_transferred));
+            bind_handler(init.completion_handler, ec, bytes_transferred));
-        return completion.result.get();
+        return init.result.get();
     }
 
     friend

extras/beast/test/string_istream.hpp

@@ -8,7 +8,7 @@
 #ifndef BEAST_TEST_STRING_ISTREAM_HPP
 #define BEAST_TEST_STRING_ISTREAM_HPP
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/error.hpp>
 #include <beast/core/prepare_buffer.hpp>
@@ -76,8 +76,8 @@ public:
     }
 
     template<class MutableBufferSequence, class ReadHandler>
-    typename async_completion<ReadHandler,
+    BEAST_INITFN_RESULT_TYPE(
-        void(error_code, std::size_t)>::result_type
+        ReadHandler, void(error_code, std::size_t))
     async_read_some(MutableBufferSequence const& buffers,
         ReadHandler&& handler)
     {
@@ -89,10 +89,10 @@ public:
         else
             ec = boost::asio::error::eof;
         async_completion<ReadHandler,
-            void(error_code, std::size_t)> completion{handler};
+            void(error_code, std::size_t)> init{handler};
         ios_.post(bind_handler(
-            completion.handler, ec, n));
+            init.completion_handler, ec, n));
-        return completion.result.get();
+        return init.result.get();
     }
 
     template<class ConstBufferSequence>
@@ -115,16 +115,16 @@ public:
     }
 
     template<class ConstBuffeSequence, class WriteHandler>
-    typename async_completion<WriteHandler,
+    BEAST_INITFN_RESULT_TYPE(
-        void(error_code, std::size_t)>::result_type
+        WriteHandler, void(error_code, std::size_t))
     async_write_some(ConstBuffeSequence const& buffers,
         WriteHandler&& handler)
     {
         async_completion<WriteHandler,
-            void(error_code, std::size_t)> completion{handler};
+            void(error_code, std::size_t)> init{handler};
-        ios_.post(bind_handler(completion.handler,
+        ios_.post(bind_handler(init.completion_handler,
             error_code{}, boost::asio::buffer_size(buffers)));
-        return completion.result.get();
+        return init.result.get();
     }
 
     friend

extras/beast/test/string_ostream.hpp

@@ -8,7 +8,7 @@
 #ifndef BEAST_TEST_STRING_OSTREAM_HPP
 #define BEAST_TEST_STRING_OSTREAM_HPP
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/error.hpp>
 #include <beast/websocket/teardown.hpp>
@@ -59,16 +59,16 @@ public:
     }
 
     template<class MutableBufferSequence, class ReadHandler>
-    typename async_completion<ReadHandler,
+    BEAST_INITFN_RESULT_TYPE(
-        void(error_code, std::size_t)>::result_type
+        ReadHandler, void(error_code, std::size_t))
     async_read_some(MutableBufferSequence const& buffers,
         ReadHandler&& handler)
     {
         async_completion<ReadHandler,
-            void(error_code, std::size_t)> completion{handler};
+            void(error_code, std::size_t)> init{handler};
-        ios_.post(bind_handler(completion.handler,
+        ios_.post(bind_handler(init.completion_handler,
             boost::asio::error::eof, 0));
-        return completion.result.get();
+        return init.result.get();
     }
 
     template<class ConstBufferSequence>
@@ -98,19 +98,18 @@ public:
     }
 
     template<class ConstBufferSequence, class WriteHandler>
-    typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(
-        WriteHandler, void(error_code)>::result_type
+        WriteHandler, void(error_code, std::size_t))
     async_write_some(ConstBufferSequence const& buffers,
         WriteHandler&& handler)
     {
         error_code ec;
         auto const bytes_transferred = write_some(buffers, ec);
-        async_completion<
+        async_completion<WriteHandler,
-            WriteHandler, void(error_code, std::size_t)
+            void(error_code, std::size_t)> init{handler};
-                > completion{handler};
         get_io_service().post(
-            bind_handler(completion.handler, ec, bytes_transferred));
+            bind_handler(init.completion_handler, ec, bytes_transferred));
-        return completion.result.get();
+        return init.result.get();
     }
 
     friend

include/beast/core.hpp

@@ -10,7 +10,7 @@
 
 #include <beast/config.hpp>
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/buffer_cat.hpp>
 #include <beast/core/buffer_concepts.hpp>

include/beast/core/async_completion.hpp

@@ -1,88 +0,0 @@
-//
-// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BEAST_ASYNC_COMPLETION_HPP
-#define BEAST_ASYNC_COMPLETION_HPP
-
-#include <beast/config.hpp>
-#include <beast/core/handler_concepts.hpp>
-#include <boost/asio/async_result.hpp>
-#include <boost/asio/handler_type.hpp>
-#include <type_traits>
-#include <utility>
-
-namespace beast {
-
-/** Helper for customizing the return type of asynchronous initiation functions.
-
-    This class template is used to transform caller-provided completion
-    handlers in calls to asynchronous initiation functions. The transformation
-    allows customization of the return type of the initiating function, and the
-    function signature of the final handler.
-
-    @tparam CompletionHandler A completion handler, or a user defined type
-    with specializations for customizing the return type (for example,
-    `boost::asio::use_future` or `boost::asio::yield_context`).
-
-    @tparam Signature The callable signature of the final completion handler.
-
-    Example:
-    @code
-    ...
-    template<class CompletionHandler>
-    typename async_completion<CompletionHandler,
-        void(error_code)>::result_type
-    async_initfn(..., CompletionHandler&& handler)
-    {
-        async_completion<CompletionHandler,
-            void(error_code)> completion{handler};
-        ...
-        return completion.result.get();
-    }
-    @endcode
-
-    @note See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3896.pdf">
-        Library Foundations For Asynchronous Operations</a>
-*/
-template<class CompletionHandler, class Signature>
-struct async_completion
-{
-    /** The type of the final handler called by the asynchronous initiation function.
-
-        Objects of this type will be callable with the specified signature.
-    */
-    using handler_type =
-        typename boost::asio::handler_type<
-            CompletionHandler, Signature>::type;
-
-    /// The type of the value returned by the asynchronous initiation function.
-    using result_type = typename
-        boost::asio::async_result<handler_type>::type;
-
-    /** Construct the helper.
-
-        @param token The completion handler. Copies will be made as
-        required. If `CompletionHandler` is movable, it may also be moved.
-    */
-    async_completion(typename std::remove_reference<CompletionHandler>::type& token)
-        : handler(std::forward<CompletionHandler>(token))
-        , result(handler)
-    {
-        static_assert(is_CompletionHandler<handler_type, Signature>::value,
-            "Handler requirements not met");
-    }
-
-    /// The final completion handler, callable with the specified signature.
-    handler_type handler;
-
-    /// The return value of the asynchronous initiation function.
-    boost::asio::async_result<handler_type> result;
-};
-
-} // beast
-
-#endif

include/beast/core/async_result.hpp

@@ -0,0 +1,188 @@
+//
+// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BEAST_ASYNC_COMPLETION_HPP
+#define BEAST_ASYNC_COMPLETION_HPP
+
+#include <beast/config.hpp>
+#include <beast/core/handler_concepts.hpp>
+#include <beast/core/detail/type_traits.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/handler_type.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace beast {
+
+/** An interface for customising the behaviour of an initiating function.
+
+    The async_result class is used for determining:
+    
+    @li the concrete completion handler type to be called at the end of the
+    asynchronous operation;
+    
+    @li the initiating function return type; and
+    
+    @li how the return value of the initiating function is obtained.
+    
+    The trait allows the handler and return types to be determined at the point
+    where the specific completion handler signature is known.
+
+    This template takes advantage of specializations of both
+    `boost::asio_async_result` and `boost::asio::handler_type` for user-defined
+    completion token types. The primary template assumes that the
+    @b CompletionToken is the completion handler.
+
+    @see @ref BEAST_INITFN_RESULT_TYPE, @ref BEAST_HANDLER_TYPE
+*/
+template<class CompletionToken, class Signature>
+class async_result
+{
+    static_assert(! std::is_reference<
+        CompletionToken>::value, "");
+
+    boost::asio::async_result<typename
+        boost::asio::handler_type<CompletionToken,
+            Signature>::type> impl_;
+
+    async_result(async_result const&) = delete;
+    async_result& operator=(async_result const&) = delete;
+
+public:
+    /// The concrete completion handler type for the specific signature.
+    using completion_handler_type =
+        typename boost::asio::handler_type<
+            CompletionToken, Signature>::type;
+
+    /// The return type of the initiating function.
+    using return_type =
+        typename boost::asio::async_result<
+            completion_handler_type>::type;
+
+    /** Construct an async result from a given handler.
+    
+        When using a specalised async_result, the constructor has
+        an opportunity to initialise some state associated with the
+        completion handler, which is then returned from the initiating
+        function.
+    */
+    explicit
+    async_result(completion_handler_type& h)
+        : impl_(h)
+    {
+    }
+
+    /// Obtain the value to be returned from the initiating function.
+    return_type
+    get()
+    {
+        return impl_.get();
+    }
+};
+
+/** Helper for customizing the return type of asynchronous initiation functions.
+
+    This class template is used to transform caller-provided completion
+    handlers in calls to asynchronous initiation functions. The transformation
+    allows customization of the return type of the initiating function, and the
+    function signature of the final handler.
+
+    @tparam CompletionToken A completion handler, or a user defined type
+    with specializations for customizing the return type (for example,
+    `boost::asio::use_future` or `boost::asio::yield_context`).
+
+    @tparam Signature The callable signature of the final completion handler.
+
+    Example:
+    @code
+    ...
+    template<class CompletionToken>
+    typename async_completion<CompletionToken, void(error_code)>::result_type
+    async_initfn(..., CompletionToken&& handler)
+    {
+        async_completion<CompletionToken, void(error_code)> completion{handler};
+        ...
+        return completion.result.get();
+    }
+    @endcode
+    
+    @tparam CompletionToken Specifies the model used to obtain the result of
+    the asynchronous operation.
+
+    @tparam Signature The call signature for the completion handler type invoked
+    on completion of the asynchronous operation.
+
+    @note See <a href="http://cplusplus.github.io/networking-ts/draft.pdf">
+        Working Draft, C++ Extensions for Networking</a>
+*/
+template<class CompletionToken, class Signature>
+struct async_completion
+{
+    /** The type of the final handler called by the asynchronous initiation function.
+
+        Objects of this type will be callable with the specified signature.
+    */
+    using completion_handler_type = typename async_result<
+        typename std::decay<CompletionToken>::type,
+            Signature>::completion_handler_type;
+
+    /** Constructor
+
+        The constructor creates the concrete completion handler and
+        makes the link between the handler and the asynchronous
+        result.
+
+        @param token The completion token. If this is a regular completion
+        handler, copies may be made as needed. If the handler is movable,
+        it may also be moved.
+    */
+    explicit
+    async_completion(CompletionToken& token)
+        : completion_handler(static_cast<typename std::conditional<
+            std::is_same<CompletionToken, completion_handler_type>::value,
+                completion_handler_type&, CompletionToken&&>::type>(token))
+        , result(completion_handler)
+    {
+        // CompletionToken is not invokable with the given signature
+        static_assert(is_CompletionHandler<
+                completion_handler_type, Signature>::value,
+            "CompletionToken requirements not met (Signature mismatch)");
+    }
+
+    /// The final completion handler, callable with the specified signature.
+    typename std::conditional<std::is_same<
+        CompletionToken, completion_handler_type>::value,
+            completion_handler_type&,
+            completion_handler_type
+                >::type completion_handler;
+
+    /// The return value of the asynchronous initiation function.
+    async_result<typename std::decay<
+        CompletionToken>::type, Signature> result;
+};
+
+/// @file
+
+/** @def BEAST_INITFN_RESULT_TYPE(ct, sig)
+
+    A macro to customize the return value of asynchronous initiation functions.
+*/
+#define BEAST_INITFN_RESULT_TYPE(ct, sig) \
+    typename async_result< \
+        typename std::decay<ct>::type, sig>::return_type
+
+/** @def BEAST_HANDLER_TYPE(ct, sig)
+
+    A helper macro to convert a completion token to a completion handler type.
+*/
+#define BEAST_HANDLER_TYPE(ct, sig) \
+    typename async_result< \
+        typename std::decay<ct>::type, sig>::completion_handler_type
+
+} // beast
+
+#endif

include/beast/core/buffer_concepts.hpp

@@ -15,44 +15,37 @@
 
 namespace beast {
 
-/// Determine if `T` meets the requirements of @b `BufferSequence`.
+/// Determine if `T` meets the requirements of @b ConstBufferSequence.
-template<class T, class BufferType>
+template<class T>
 #if BEAST_DOXYGEN
-struct is_BufferSequence : std::integral_constant<bool, ...>
+struct is_const_buffer_sequence : std::integral_constant<bool, ...>
 #else
-struct is_BufferSequence : detail::is_BufferSequence<T, BufferType>::type
+struct is_const_buffer_sequence :
+    detail::is_buffer_sequence<T,
+        boost::asio::const_buffer>::type
 #endif
 {
 };
 
-/// Determine if `T` meets the requirements of @b `ConstBufferSequence`.
+/// Determine if `T` meets the requirements of @b DynamicBuffer.
 template<class T>
 #if BEAST_DOXYGEN
-struct is_ConstBufferSequence : std::integral_constant<bool, ...>
+struct is_dynamic_buffer : std::integral_constant<bool, ...>
 #else
-struct is_ConstBufferSequence :
+struct is_dynamic_buffer :
-    is_BufferSequence<T, boost::asio::const_buffer>
+    detail::is_dynamic_buffer<T>::type
 #endif
 {
 };
 
-/// Determine if `T` meets the requirements of @b `DynamicBuffer`.
+/// Determine if `T` meets the requirements of @b MutableBufferSequence.
 template<class T>
 #if BEAST_DOXYGEN
-struct is_DynamicBuffer : std::integral_constant<bool, ...>
+struct is_mutable_buffer_sequence : std::integral_constant<bool, ...>
 #else
-struct is_DynamicBuffer : detail::is_DynamicBuffer<T>::type
+struct is_mutable_buffer_sequence :
-#endif
+    detail::is_buffer_sequence<T,
-{
+        boost::asio::mutable_buffer>::type
-};
-
-/// Determine if `T` meets the requirements of @b `MutableBufferSequence`.
-template<class T>
-#if BEAST_DOXYGEN
-struct is_MutableBufferSequence : std::integral_constant<bool, ...>
-#else
-struct is_MutableBufferSequence :
-    is_BufferSequence<T, boost::asio::mutable_buffer>
 #endif
 {
 };

include/beast/core/buffered_read_stream.hpp

@@ -9,7 +9,7 @@
 #define BEAST_BUFFERED_READ_STREAM_HPP
 
 #include <beast/config.hpp>
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/buffer_concepts.hpp>
 #include <beast/core/error.hpp>
 #include <beast/core/stream_concepts.hpp>
@@ -90,7 +90,7 @@ namespace beast {
 template<class Stream, class DynamicBuffer>
 class buffered_read_stream
 {
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
 
     template<class Buffers, class Handler>
@@ -272,11 +272,7 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class MutableBufferSequence, class ReadHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(ReadHandler, void(error_code))
-    void_or_deduced
-#else
-    typename async_completion<ReadHandler, void(error_code)>::result_type
-#endif
     async_read_some(MutableBufferSequence const& buffers,
         ReadHandler&& handler);
 
@@ -347,11 +343,7 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class ConstBufferSequence, class WriteHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(WriteHandler, void(error_code))
-    void_or_deduced
-#else
-    typename async_completion<WriteHandler, void(error_code)>::result_type
-#endif
     async_write_some(ConstBufferSequence const& buffers,
         WriteHandler&& handler);
 };

include/beast/core/buffers_adapter.hpp

@@ -32,7 +32,7 @@ namespace beast {
 template<class MutableBufferSequence>
 class buffers_adapter
 {
-    static_assert(is_MutableBufferSequence<MutableBufferSequence>::value,
+    static_assert(is_mutable_buffer_sequence<MutableBufferSequence>::value,
         "MutableBufferSequence requirements not met");
 
     using iter_type = typename MutableBufferSequence::const_iterator;

include/beast/core/consuming_buffers.hpp

@@ -9,7 +9,6 @@
 #define BEAST_CONSUMING_BUFFERS_HPP
 
 #include <beast/config.hpp>
-#include <beast/core/buffer_concepts.hpp>
 #include <boost/asio/buffer.hpp>
 #include <cstdint>
 #include <iterator>

include/beast/core/detail/buffer_concepts.hpp

@@ -33,7 +33,7 @@ using MutableBufferSequence =
     BufferSequence<boost::asio::mutable_buffer>;
 
 template<class T, class BufferType>
-class is_BufferSequence
+class is_buffer_sequence
 {
     template<class U, class R = std::is_convertible<
         typename U::value_type, BufferType> >
@@ -88,19 +88,19 @@ public:
 template<class B1, class... Bn>
 struct is_all_ConstBufferSequence
     : std::integral_constant<bool,
-        is_BufferSequence<B1, boost::asio::const_buffer>::type::value &&
+        is_buffer_sequence<B1, boost::asio::const_buffer>::type::value &&
         is_all_ConstBufferSequence<Bn...>::value>
 {
 };
 
 template<class B1>
 struct is_all_ConstBufferSequence<B1>
-    : is_BufferSequence<B1, boost::asio::const_buffer>::type
+    : is_buffer_sequence<B1, boost::asio::const_buffer>::type
 {
 };
 
 template<class T>
-class is_DynamicBuffer
+class is_dynamic_buffer
 {
     // size()
     template<class U, class R = std::is_convertible<decltype(
@@ -128,7 +128,7 @@ class is_DynamicBuffer
 
     // data()
     template<class U, class R = std::integral_constant<
-        bool, is_BufferSequence<decltype(
+        bool, is_buffer_sequence<decltype(
             std::declval<U const>().data()),
                 boost::asio::const_buffer>::type::value>>
     static R check4(int);
@@ -138,7 +138,7 @@ class is_DynamicBuffer
 
     // prepare()
     template<class U, class R = std::integral_constant<
-        bool, is_BufferSequence<decltype(
+        bool, is_buffer_sequence<decltype(
             std::declval<U>().prepare(1)),
                 boost::asio::mutable_buffer>::type::value>>
     static R check5(int);

include/beast/core/detail/sync_ostream.hpp

@@ -51,7 +51,7 @@ sync_ostream::
 write_some(ConstBufferSequence const& buffers)
 {
     static_assert(
-        is_ConstBufferSequence<ConstBufferSequence>::value,
+        is_const_buffer_sequence<ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     error_code ec;
     auto const n = write_some(buffers, ec);
@@ -67,7 +67,7 @@ write_some(ConstBufferSequence const& buffers,
     error_code& ec)
 {
     static_assert(
-        is_ConstBufferSequence<ConstBufferSequence>::value,
+        is_const_buffer_sequence<ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     std::size_t n = 0;
     using boost::asio::buffer_cast;

include/beast/core/impl/buffered_read_stream.ipp

@@ -162,12 +162,11 @@ auto
 buffered_read_stream<Stream, DynamicBuffer>::
 async_write_some(ConstBufferSequence const& buffers,
         WriteHandler&& handler) ->
-        typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(WriteHandler, void(error_code))
-            WriteHandler, void(error_code)>::result_type
 {
     static_assert(is_AsyncWriteStream<next_layer_type>::value,
         "AsyncWriteStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(is_CompletionHandler<WriteHandler,
@@ -186,7 +185,7 @@ read_some(
 {
     static_assert(is_SyncReadStream<next_layer_type>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_MutableBufferSequence<
+    static_assert(is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
             "MutableBufferSequence requirements not met");
     error_code ec;
@@ -205,7 +204,7 @@ read_some(MutableBufferSequence const& buffers,
 {
     static_assert(is_SyncReadStream<next_layer_type>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_MutableBufferSequence<
+    static_assert(is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
             "MutableBufferSequence requirements not met");
     using boost::asio::buffer_size;
@@ -229,24 +228,21 @@ template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence, class ReadHandler>
 auto
 buffered_read_stream<Stream, DynamicBuffer>::
-async_read_some(
+async_read_some(MutableBufferSequence const& buffers,
-    MutableBufferSequence const& buffers,
         ReadHandler&& handler) ->
-            typename async_completion<
+    BEAST_INITFN_RESULT_TYPE(ReadHandler, void(error_code))
-                ReadHandler, void(error_code)>::result_type
 {
     static_assert(is_AsyncReadStream<next_layer_type>::value,
         "Stream requirements not met");
-    static_assert(is_MutableBufferSequence<
+    static_assert(is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
             "MutableBufferSequence requirements not met");
-    beast::async_completion<
+    async_completion<ReadHandler,
-        ReadHandler, void(error_code, std::size_t)
+        void(error_code, std::size_t)> init{handler};
-            > completion{handler};
+    read_some_op<MutableBufferSequence, BEAST_HANDLER_TYPE(
-    read_some_op<MutableBufferSequence,
+        ReadHandler, void(error_code, std::size_t))>{
-        decltype(completion.handler)>{
+            init.completion_handler, *this, buffers};
-            completion.handler, *this, buffers};
+    return init.result.get();
-    return completion.result.get();
 }
 
 } // beast

include/beast/core/impl/consuming_buffers.ipp

@@ -9,7 +9,6 @@
 #define BEAST_IMPL_CONSUMING_BUFFERS_IPP
 
 #include <beast/core/buffer_concepts.hpp>
-#include <boost/asio/buffer.hpp>
 #include <algorithm>
 #include <cstdint>
 #include <iterator>
@@ -163,7 +162,8 @@ consuming_buffers(BufferSequence const& bs)
     , begin_(bs_.begin())
 {
     static_assert(
-        is_BufferSequence<BufferSequence, value_type>::value,
+        is_const_buffer_sequence<BufferSequence>::value||
+        is_mutable_buffer_sequence<BufferSequence>::value,
             "BufferSequence requirements not met");
 }
 

include/beast/core/ostream.hpp

@@ -44,7 +44,7 @@ detail::buffers_helper<ConstBufferSequence>
 #endif
 buffers(ConstBufferSequence const& b)
 {
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence not met");
     return detail::buffers_helper<
@@ -86,7 +86,7 @@ detail::ostream_helper<
 #endif
 ostream(DynamicBuffer& buffer)
 {
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     return detail::ostream_helper<
         DynamicBuffer, char, std::char_traits<char>,

include/beast/http/concepts.hpp

@@ -159,7 +159,7 @@ struct is_Reader<T, M, beast::detail::void_t<decltype(
         std::declval<std::size_t>()),
     std::declval<T>().finish()
             )> > : std::integral_constant<bool,
-    is_MutableBufferSequence<
+    is_mutable_buffer_sequence<
         typename T::mutable_buffers_type>::value &&
     std::is_convertible<decltype(
         std::declval<T>().prepare(

include/beast/http/impl/async_read.ipp

@@ -572,34 +572,34 @@ template<
     class DynamicBuffer,
     bool isRequest, class Derived,
     class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code, std::size_t)>::result_type
+    ReadHandler, void(error_code, std::size_t))
 async_read_some(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
     basic_parser<isRequest, true, Derived>& parser,
     ReadHandler&& handler)
 {
-    beast::async_completion<ReadHandler,
+    async_completion<ReadHandler,
-        void(error_code, std::size_t)> completion{handler};
+        void(error_code, std::size_t)> init{handler};
     switch(parser.state())
     {
     case parse_state::header:
     case parse_state::chunk_header:
         detail::read_some_buffer_op<AsyncReadStream,
-            DynamicBuffer, isRequest, true, Derived,
+            DynamicBuffer, isRequest, true, Derived, BEAST_HANDLER_TYPE(
-                decltype(completion.handler)>{
+                ReadHandler, void(error_code, std::size_t))>{
-                    completion.handler, stream, dynabuf, parser};
+                    init.completion_handler, stream, dynabuf, parser};
         break;
 
     default:
         detail::read_some_body_op<AsyncReadStream,
-            DynamicBuffer, isRequest, Derived,
+            DynamicBuffer, isRequest, Derived, BEAST_HANDLER_TYPE(
-                decltype(completion.handler)>{
+                ReadHandler, void(error_code, std::size_t))>{
-                    completion.handler, stream, dynabuf, parser};
+                    init.completion_handler, stream, dynabuf, parser};
         break;
     }
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<
@@ -608,21 +608,21 @@ template<
     bool isRequest, class Derived,
     class ReadHandler>
 inline
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code, std::size_t)>::result_type
+    ReadHandler, void(error_code, std::size_t))
 async_read_some(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
     basic_parser<isRequest, false, Derived>& parser,
     ReadHandler&& handler)
 {
-    beast::async_completion<ReadHandler,
+    async_completion<ReadHandler,
-        void(error_code, std::size_t)> completion{handler};
+        void(error_code, std::size_t)> init{handler};
     detail::read_some_buffer_op<AsyncReadStream,
-        DynamicBuffer, isRequest, false, Derived,
+        DynamicBuffer, isRequest, false, Derived, BEAST_HANDLER_TYPE(
-            decltype(completion.handler)>{
+            ReadHandler, void(error_code, std::size_t))>{
-                completion.handler, stream, dynabuf, parser};
+                init.completion_handler, stream, dynabuf, parser};
-    return completion.result.get();
+    return init.result.get();
 }
 
 } // detail
@@ -634,8 +634,8 @@ template<
     class DynamicBuffer,
     bool isRequest, bool isDirect, class Derived,
     class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code, std::size_t)>::result_type
+    ReadHandler, void(error_code, std::size_t))
 async_read_some(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
@@ -644,7 +644,7 @@ async_read_some(
 {
     static_assert(is_AsyncReadStream<AsyncReadStream>::value,
         "AsyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
     return detail::async_read_some(stream, dynabuf, parser,
@@ -656,8 +656,8 @@ template<
     class DynamicBuffer,
     bool isRequest, bool isDirect, class Derived,
     class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code)>::result_type
+    ReadHandler, void(error_code))
 async_read(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
@@ -666,15 +666,16 @@ async_read(
 {
     static_assert(is_AsyncReadStream<AsyncReadStream>::value,
         "AsyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
-    beast::async_completion<ReadHandler,
+    async_completion<ReadHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     detail::parse_op<AsyncReadStream, DynamicBuffer,
-        isRequest, isDirect, Derived, decltype(completion.handler)>{
+        isRequest, isDirect, Derived, BEAST_HANDLER_TYPE(
-            completion.handler, stream, dynabuf, parser};
+            ReadHandler, void(error_code))>{
-    return completion.result.get();
+                init.completion_handler, stream, dynabuf, parser};
+    return init.result.get();
 }
 
 template<
@@ -682,8 +683,8 @@ template<
     class DynamicBuffer,
     bool isRequest, class Body, class Fields,
     class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code)>::result_type
+    ReadHandler, void(error_code))
 async_read(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
@@ -692,7 +693,7 @@ async_read(
 {
     static_assert(is_AsyncReadStream<AsyncReadStream>::value,
         "AsyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     static_assert(is_Body<Body>::value,
         "Body requirements not met");
@@ -701,13 +702,13 @@ async_read(
     static_assert(is_Reader<typename Body::reader,
         message<isRequest, Body, Fields>>::value,
             "Reader requirements not met");
-    beast::async_completion<ReadHandler,
+    async_completion<ReadHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     detail::read_message_op<AsyncReadStream, DynamicBuffer,
-        isRequest, Body, Fields, decltype(
+        isRequest, Body, Fields, BEAST_HANDLER_TYPE(
-            completion.handler)>{completion.handler,
+            ReadHandler, void(error_code))>{
-                stream, dynabuf, msg};
+                init.completion_handler, stream, dynabuf, msg};
-    return completion.result.get();
+    return init.result.get();
 }
 
 } // http

include/beast/http/impl/basic_parser.ipp

@@ -71,7 +71,7 @@ basic_parser<isRequest, isDirect, Derived>::
 write(ConstBufferSequence const& buffers,
     error_code& ec)
 {
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     auto const buffer = maybe_flatten(buffers);

include/beast/http/impl/read.ipp

@@ -192,7 +192,7 @@ read_some(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
     error_code ec;
@@ -216,7 +216,7 @@ read_some(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
     return detail::read_some(stream, dynabuf, parser, ec);
@@ -234,7 +234,7 @@ read(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
     error_code ec;
@@ -256,7 +256,7 @@ read(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     BOOST_ASSERT(! parser.is_complete());
     do
@@ -282,7 +282,7 @@ read(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     static_assert(is_Body<Body>::value,
         "Body requirements not met");
@@ -310,7 +310,7 @@ read(
 {
     static_assert(is_SyncReadStream<SyncReadStream>::value,
         "SyncReadStream requirements not met");
-    static_assert(is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     static_assert(is_Body<Body>::value,
         "Body requirements not met");

include/beast/http/impl/write.ipp

@@ -213,16 +213,16 @@ write(SyncWriteStream& stream,
 template<class AsyncWriteStream,
     bool isRequest, class Fields,
         class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 async_write(AsyncWriteStream& stream,
     header<isRequest, Fields> const& msg,
         WriteHandler&& handler)
 {
     static_assert(is_AsyncWriteStream<AsyncWriteStream>::value,
         "AsyncWriteStream requirements not met");
-    beast::async_completion<WriteHandler,
+    async_completion<WriteHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     multi_buffer b;
     {
         auto os = ostream(b);
@@ -231,9 +231,9 @@ async_write(AsyncWriteStream& stream,
         os << "\r\n";
     }
     detail::write_streambuf_op<AsyncWriteStream,
-        decltype(completion.handler)>{
+        BEAST_HANDLER_TYPE(WriteHandler, void(error_code))>{
-            completion.handler, stream, std::move(b)};
+            init.completion_handler, stream, std::move(b)};
-    return completion.result.get();
+    return init.result.get();
 }
 
 //------------------------------------------------------------------------------
@@ -641,8 +641,8 @@ write(SyncWriteStream& stream,
 template<class AsyncWriteStream,
     bool isRequest, class Body, class Fields,
         class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 async_write(AsyncWriteStream& stream,
     message<isRequest, Body, Fields> const& msg,
         WriteHandler&& handler)
@@ -656,11 +656,12 @@ async_write(AsyncWriteStream& stream,
     static_assert(is_Writer<typename Body::writer,
         message<isRequest, Body, Fields>>::value,
             "Writer requirements not met");
-    beast::async_completion<WriteHandler,
+    async_completion<WriteHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    detail::write_op<AsyncWriteStream, decltype(completion.handler),
+    detail::write_op<AsyncWriteStream, BEAST_HANDLER_TYPE(
-        isRequest, Body, Fields>{completion.handler, stream, msg};
+        WriteHandler, void(error_code)), isRequest,
-    return completion.result.get();
+            Body, Fields>{init.completion_handler, stream, msg};
+    return init.result.get();
 }
 
 //------------------------------------------------------------------------------

include/beast/http/read.hpp

@@ -9,7 +9,7 @@
 #define BEAST_HTTP_READ_HPP
 
 #include <beast/config.hpp>
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/error.hpp>
 #include <beast/http/basic_parser.hpp>
 #include <beast/http/message.hpp>
@@ -179,12 +179,8 @@ template<
     class DynamicBuffer,
     bool isRequest, bool isDirect, class Derived,
     class ReadHandler>
-#if BEAST_DOXYGEN
+BEAST_INITFN_RESULT_TYPE(
-void_or_deduced
+    ReadHandler, void(error_code, std::size_t))
-#else
-typename async_completion<
-    ReadHandler, void(error_code, std::size_t)>::result_type
-#endif
 async_read_some(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
@@ -318,12 +314,8 @@ template<
     class DynamicBuffer,
     bool isRequest, bool isDirect, class Derived,
     class ReadHandler>
-#if BEAST_DOXYGEN
+BEAST_INITFN_RESULT_TYPE(
-void_or_deduced
+    ReadHandler, void(error_code))
-#else
-typename async_completion<
-    ReadHandler, void(error_code)>::result_type
-#endif
 async_read(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,
@@ -462,12 +454,8 @@ template<
     class DynamicBuffer,
     bool isRequest, class Body, class Fields,
     class ReadHandler>
-#if BEAST_DOXYGEN
+BEAST_INITFN_RESULT_TYPE(
-void_or_deduced
+    ReadHandler, void(error_code))
-#else
-typename async_completion<
-    ReadHandler, void(error_code)>::result_type
-#endif
 async_read(
     AsyncReadStream& stream,
     DynamicBuffer& dynabuf,

include/beast/http/write.hpp

@@ -11,7 +11,7 @@
 #include <beast/config.hpp>
 #include <beast/http/message.hpp>
 #include <beast/core/error.hpp>
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <ostream>
 #include <type_traits>
 
@@ -121,12 +121,8 @@ write(SyncWriteStream& stream,
 template<class AsyncWriteStream,
     bool isRequest, class Fields,
         class WriteHandler>
-#if BEAST_DOXYGEN
+BEAST_INITFN_RESULT_TYPE(
-void_or_deduced
+    WriteHandler, void(error_code))
-#else
-typename async_completion<
-    WriteHandler, void(error_code)>::result_type
-#endif
 async_write(AsyncWriteStream& stream,
     header<isRequest, Fields> const& msg,
         WriteHandler&& handler);
@@ -240,12 +236,8 @@ write(SyncWriteStream& stream,
 template<class AsyncWriteStream,
     bool isRequest, class Body, class Fields,
         class WriteHandler>
-#if BEAST_DOXYGEN
+BEAST_INITFN_RESULT_TYPE(
-void_or_deduced
+    WriteHandler, void(error_code))
-#else
-typename async_completion<
-    WriteHandler, void(error_code)>::result_type
-#endif
 async_write(AsyncWriteStream& stream,
     message<isRequest, Body, Fields> const& msg,
         WriteHandler&& handler);

include/beast/websocket/detail/utf8_checker.hpp

@@ -125,7 +125,7 @@ template<class ConstBufferSequence>
 bool
 utf8_checker_t<_>::write(ConstBufferSequence const& bs)
 {
-    static_assert(is_ConstBufferSequence<ConstBufferSequence>::value,
+    static_assert(is_const_buffer_sequence<ConstBufferSequence>::value,
         "ConstBufferSequence requirements not met");
     using boost::asio::buffer_cast;
     using boost::asio::buffer_size;

include/beast/websocket/impl/accept.ipp

@@ -360,7 +360,7 @@ accept(ConstBufferSequence const& buffers)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     error_code ec;
@@ -379,7 +379,7 @@ accept_ex(ConstBufferSequence const& buffers,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(detail::is_ResponseDecorator<
@@ -399,7 +399,7 @@ accept(ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     reset();
@@ -421,10 +421,10 @@ accept_ex(ConstBufferSequence const& buffers,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     reset();
@@ -506,7 +506,7 @@ accept(http::header<true, Fields> const& req,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     error_code ec;
@@ -526,7 +526,7 @@ accept_ex(http::header<true, Fields> const& req,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(detail::is_ResponseDecorator<
@@ -547,7 +547,7 @@ accept(http::header<true, Fields> const& req,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     reset();
@@ -571,7 +571,7 @@ accept_ex(http::header<true, Fields> const& req,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(detail::is_ResponseDecorator<
@@ -590,26 +590,26 @@ accept_ex(http::header<true, Fields> const& req,
 
 template<class NextLayer>
 template<class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept(AcceptHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
     accept_op<decltype(&default_decorate_res),
-        decltype(completion.handler)>{completion.handler,
+        BEAST_HANDLER_TYPE(AcceptHandler, void(error_code))>{
-            *this, &default_decorate_res};
+            init.completion_handler, *this, &default_decorate_res};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class ResponseDecorator, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept_ex(ResponseDecorator const& decorator,
     AcceptHandler&& handler)
@@ -619,41 +619,42 @@ async_accept_ex(ResponseDecorator const& decorator,
     static_assert(detail::is_ResponseDecorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    accept_op<ResponseDecorator, decltype(completion.handler)>{
+    accept_op<ResponseDecorator, BEAST_HANDLER_TYPE(
-        completion.handler, *this, decorator};
+        AcceptHandler, void(error_code))>{
-    return completion.result.get();
+            init.completion_handler, *this, decorator};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class ConstBufferSequence, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept(ConstBufferSequence const& buffers,
     AcceptHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
     accept_op<decltype(&default_decorate_res),
-        decltype(completion.handler)>{completion.handler,
+        BEAST_HANDLER_TYPE(AcceptHandler, void(error_code))>{
-        *this, buffers, &default_decorate_res};
+            init.completion_handler, *this, buffers, &default_decorate_res};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class ConstBufferSequence,
     class ResponseDecorator, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept_ex(ConstBufferSequence const& buffers,
     ResponseDecorator const& decorator,
@@ -661,45 +662,47 @@ async_accept_ex(ConstBufferSequence const& buffers,
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(detail::is_ResponseDecorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    accept_op<ResponseDecorator, decltype(completion.handler)>{
+    accept_op<ResponseDecorator, BEAST_HANDLER_TYPE(
-        completion.handler, *this, buffers, decorator};
+        AcceptHandler, void(error_code))>{
-    return completion.result.get();
+            init.completion_handler, *this, buffers, decorator};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class Fields, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept(http::header<true, Fields> const& req,
     AcceptHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    response_op<decltype(completion.handler)>{
+    response_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, req,
+        AcceptHandler, void(error_code))>{init.completion_handler,
-            &default_decorate_res, beast_asio_helpers::
+            *this, req, &default_decorate_res,
-                is_continuation(completion.handler)};
+                beast_asio_helpers::is_continuation(
-    return completion.result.get();
+                    init.completion_handler)};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class Fields,
     class ResponseDecorator, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept_ex(http::header<true, Fields> const& req,
     ResponseDecorator const& decorator, AcceptHandler&& handler)
@@ -709,21 +712,22 @@ async_accept_ex(http::header<true, Fields> const& req,
     static_assert(detail::is_ResponseDecorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    response_op<decltype(completion.handler)>{
+    response_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, req, decorator,
+        AcceptHandler, void(error_code))>{
+            init.completion_handler, *this, req, decorator,
                 beast_asio_helpers::is_continuation(
-                completion.handler)};
+                    init.completion_handler)};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class Fields,
     class ConstBufferSequence, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept(http::header<true, Fields> const& req,
     ConstBufferSequence const& buffers,
@@ -731,24 +735,25 @@ async_accept(http::header<true, Fields> const& req,
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    response_op<decltype(completion.handler)>{
+    response_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, req, buffers,
+        AcceptHandler, void(error_code))>{
+            init.completion_handler, *this, req, buffers,
                 &default_decorate_res, beast_asio_helpers::
-                    is_continuation(completion.handler)};
+                    is_continuation(init.completion_handler)};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class Fields, class ConstBufferSequence,
     class ResponseDecorator, class AcceptHandler>
-typename async_completion<AcceptHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    AcceptHandler, void(error_code))
 stream<NextLayer>::
 async_accept_ex(http::header<true, Fields> const& req,
     ConstBufferSequence const& buffers,
@@ -757,20 +762,21 @@ async_accept_ex(http::header<true, Fields> const& req,
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(is_ConstBufferSequence<
+    static_assert(is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     static_assert(detail::is_ResponseDecorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    beast::async_completion<AcceptHandler,
+    async_completion<AcceptHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
     reset();
-    response_op<decltype(completion.handler)>{
+    response_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, req, buffers, decorator,
+        AcceptHandler, void(error_code))>{init.completion_handler,
+            *this, req, buffers, decorator,
                 beast_asio_helpers::is_continuation(
-                completion.handler)};
+                    init.completion_handler)};
-    return completion.result.get();
+    return init.result.get();
 }
 
 } // websocket

include/beast/websocket/impl/close.ipp

@@ -197,19 +197,19 @@ upcall:
 
 template<class NextLayer>
 template<class CloseHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    CloseHandler, void(error_code)>::result_type
+    CloseHandler, void(error_code))
 stream<NextLayer>::
 async_close(close_reason const& cr, CloseHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements not met");
-    beast::async_completion<
+    async_completion<CloseHandler,
-        CloseHandler, void(error_code)
+        void(error_code)> init{handler};
-            > completion{handler};
+    close_op<BEAST_HANDLER_TYPE(
-    close_op<decltype(completion.handler)>{
+        CloseHandler, void(error_code))>{
-        completion.handler, *this, cr};
+            init.completion_handler, *this, cr};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>

include/beast/websocket/impl/handshake.ipp

@@ -160,8 +160,8 @@ operator()(error_code ec, bool again)
 
 template<class NextLayer>
 template<class HandshakeHandler>
-typename async_completion<HandshakeHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    HandshakeHandler, void(error_code))
 stream<NextLayer>::
 async_handshake(string_view const& host,
     string_view const& target,
@@ -169,18 +169,19 @@ async_handshake(string_view const& host,
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements not met");
-    beast::async_completion<HandshakeHandler,
+    async_completion<HandshakeHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    handshake_op<decltype(completion.handler)>{
+    handshake_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, nullptr,
+        HandshakeHandler, void(error_code))>{
-            host, target, &default_decorate_req};
+            init.completion_handler, *this, nullptr, host,
-    return completion.result.get();
+                target, &default_decorate_req};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class HandshakeHandler>
-typename async_completion<HandshakeHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    HandshakeHandler, void(error_code))
 stream<NextLayer>::
 async_handshake(response_type& res,
     string_view const& host,
@@ -189,18 +190,19 @@ async_handshake(response_type& res,
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements not met");
-    beast::async_completion<HandshakeHandler,
+    async_completion<HandshakeHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    handshake_op<decltype(completion.handler)>{
+    handshake_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, &res,
+        HandshakeHandler, void(error_code))>{
-            host, target, &default_decorate_req};
+            init.completion_handler, *this, &res, host,
-    return completion.result.get();
+                target, &default_decorate_req};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class RequestDecorator, class HandshakeHandler>
-typename async_completion<HandshakeHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    HandshakeHandler, void(error_code))
 stream<NextLayer>::
 async_handshake_ex(string_view const& host,
     string_view const& target,
@@ -212,18 +214,19 @@ async_handshake_ex(string_view const& host,
     static_assert(detail::is_RequestDecorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
-    beast::async_completion<HandshakeHandler,
+    async_completion<HandshakeHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    handshake_op<decltype(completion.handler)>{
+    handshake_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, nullptr,
+        HandshakeHandler, void(error_code))>{
-            host, target, decorator};
+            init.completion_handler, *this, nullptr, host,
-    return completion.result.get();
+                target, decorator};
+    return init.result.get();
 }
 
 template<class NextLayer>
 template<class RequestDecorator, class HandshakeHandler>
-typename async_completion<HandshakeHandler,
+BEAST_INITFN_RESULT_TYPE(
-    void(error_code)>::result_type
+    HandshakeHandler, void(error_code))
 stream<NextLayer>::
 async_handshake_ex(response_type& res,
     string_view const& host,
@@ -236,12 +239,13 @@ async_handshake_ex(response_type& res,
     static_assert(detail::is_RequestDecorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
-    beast::async_completion<HandshakeHandler,
+    async_completion<HandshakeHandler,
-        void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    handshake_op<decltype(completion.handler)>{
+    handshake_op<BEAST_HANDLER_TYPE(
-        completion.handler, *this, &res,
+        HandshakeHandler, void(error_code))>{
-            host, target, decorator};
+            init.completion_handler, *this, &res, host,
-    return completion.result.get();
+                target, decorator};
+    return init.result.get();
 }
 
 template<class NextLayer>

include/beast/websocket/impl/ping.ipp

@@ -195,38 +195,36 @@ upcall:
 
 template<class NextLayer>
 template<class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 stream<NextLayer>::
 async_ping(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    beast::async_completion<
+    async_completion<WriteHandler,
-        WriteHandler, void(error_code)
+        void(error_code)> init{handler};
-            > completion{handler};
+    ping_op<BEAST_HANDLER_TYPE(
-    ping_op<decltype(completion.handler)>{
+        WriteHandler, void(error_code))>{
-        completion.handler, *this,
+            init.completion_handler, *this, opcode::ping, payload};
-            opcode::ping, payload};
+    return init.result.get();
-    return completion.result.get();
 }
 
 template<class NextLayer>
 template<class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 stream<NextLayer>::
 async_pong(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    beast::async_completion<
+    async_completion<WriteHandler,
-        WriteHandler, void(error_code)
+        void(error_code)> init{handler};
-            > completion{handler};
+    ping_op<BEAST_HANDLER_TYPE(
-    ping_op<decltype(completion.handler)>{
+        WriteHandler, void(error_code))>{
-        completion.handler, *this,
+            init.completion_handler, *this, opcode::pong, payload};
-            opcode::pong, payload};
+    return init.result.get();
-    return completion.result.get();
 }
 
 template<class NextLayer>

include/beast/websocket/impl/read.ipp

@@ -686,21 +686,22 @@ upcall:
 
 template<class NextLayer>
 template<class DynamicBuffer, class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code)>::result_type
+    ReadHandler, void(error_code))
 stream<NextLayer>::
 async_read_frame(frame_info& fi,
     DynamicBuffer& dynabuf, ReadHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
-    beast::async_completion<
+    async_completion<ReadHandler,
-        ReadHandler, void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    read_frame_op<DynamicBuffer, decltype(completion.handler)>{
+    read_frame_op<DynamicBuffer, BEAST_HANDLER_TYPE(
-        completion.handler, *this, fi, dynabuf};
+        ReadHandler, void(error_code))>{init.completion_handler,
-    return completion.result.get();
+            *this, fi, dynabuf};
+    return init.result.get();
 }
 
 template<class NextLayer>
@@ -711,7 +712,7 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     error_code ec;
     read_frame(fi, dynabuf, ec);
@@ -727,7 +728,7 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     using beast::detail::clamp;
     using boost::asio::buffer;
@@ -1097,22 +1098,22 @@ upcall:
 
 template<class NextLayer>
 template<class DynamicBuffer, class ReadHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    ReadHandler, void(error_code)>::result_type
+    ReadHandler, void(error_code))
 stream<NextLayer>::
 async_read(opcode& op,
     DynamicBuffer& dynabuf, ReadHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
-    beast::async_completion<
+    async_completion<ReadHandler,
-        ReadHandler, void(error_code)
+        void(error_code)> init{handler};
-            > completion{handler};
+    read_op<DynamicBuffer, BEAST_HANDLER_TYPE(
-    read_op<DynamicBuffer, decltype(completion.handler)>{
+        ReadHandler, void(error_code))>{init.completion_handler,
-        completion.handler, *this, op, dynabuf};
+            *this, op, dynabuf};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
@@ -1123,7 +1124,7 @@ read(opcode& op, DynamicBuffer& dynabuf)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     error_code ec;
     read(op, dynabuf, ec);
@@ -1139,7 +1140,7 @@ read(opcode& op, DynamicBuffer& dynabuf, error_code& ec)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
+    static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     frame_info fi;
     for(;;)

include/beast/websocket/impl/ssl.ipp

@@ -8,7 +8,7 @@
 #ifndef BEAST_WEBSOCKET_IMPL_SSL_IPP_INCLUDED
 #define BEAST_WEBSOCKET_IMPL_SSL_IPP_INCLUDED
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/handler_helpers.hpp>
 #include <beast/core/handler_concepts.hpp>
 #include <beast/core/handler_ptr.hpp>

include/beast/websocket/impl/teardown.ipp

@@ -8,7 +8,7 @@
 #ifndef BEAST_WEBSOCKET_IMPL_TEARDOWN_IPP
 #define BEAST_WEBSOCKET_IMPL_TEARDOWN_IPP
 
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/handler_concepts.hpp>
 #include <beast/core/handler_helpers.hpp>
 #include <beast/core/handler_ptr.hpp>

include/beast/websocket/impl/write.ipp

@@ -545,24 +545,23 @@ upcall:
 
 template<class NextLayer>
 template<class ConstBufferSequence, class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 stream<NextLayer>::
 async_write_frame(bool fin,
     ConstBufferSequence const& bs, WriteHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    beast::async_completion<
+    async_completion<WriteHandler,
-        WriteHandler, void(error_code)
+        void(error_code)> init{handler};
-            > completion{handler};
+    write_frame_op<ConstBufferSequence, BEAST_HANDLER_TYPE(
-    write_frame_op<ConstBufferSequence, decltype(
+        WriteHandler, void(error_code))>{init.completion_handler,
-        completion.handler)>{completion.handler,
             *this, fin, bs};
-    return completion.result.get();
+    return init.result.get();
 }
 
 template<class NextLayer>
@@ -573,7 +572,7 @@ write_frame(bool fin, ConstBufferSequence const& buffers)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     error_code ec;
@@ -591,7 +590,7 @@ write_frame(bool fin,
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     using beast::detail::clamp;
@@ -896,21 +895,22 @@ operator()(error_code ec, bool again)
 
 template<class NextLayer>
 template<class ConstBufferSequence, class WriteHandler>
-typename async_completion<
+BEAST_INITFN_RESULT_TYPE(
-    WriteHandler, void(error_code)>::result_type
+    WriteHandler, void(error_code))
 stream<NextLayer>::
 async_write(ConstBufferSequence const& bs, WriteHandler&& handler)
 {
     static_assert(is_AsyncStream<next_layer_type>::value,
         "AsyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    beast::async_completion<
+    async_completion<WriteHandler,
-        WriteHandler, void(error_code)> completion{handler};
+        void(error_code)> init{handler};
-    write_op<ConstBufferSequence, decltype(completion.handler)>{
+    write_op<ConstBufferSequence, BEAST_HANDLER_TYPE(
-        completion.handler, *this, bs};
+        WriteHandler, void(error_code))>{
-    return completion.result.get();
+            init.completion_handler, *this, bs};
+    return init.result.get();
 }
 
 template<class NextLayer>
@@ -921,7 +921,7 @@ write(ConstBufferSequence const& buffers)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     error_code ec;
@@ -938,7 +938,7 @@ write(ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_SyncStream<next_layer_type>::value,
         "SyncStream requirements not met");
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     write_frame(true, buffers, ec);

include/beast/websocket/stream.hpp

@@ -14,7 +14,7 @@
 #include <beast/websocket/detail/stream_base.hpp>
 #include <beast/http/message.hpp>
 #include <beast/http/string_body.hpp>
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>
 #include <beast/core/buffered_read_stream.hpp>
 #include <beast/core/string_view.hpp>
 #include <beast/core/detail/get_lowest_layer.hpp>
@@ -970,12 +970,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<
-        AcceptHandler, void(error_code)>::result_type
-#endif
     async_accept(AcceptHandler&& handler);
 
     /** Start reading and responding to a WebSocket HTTP Upgrade request.
@@ -1029,12 +1025,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class ResponseDecorator, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<
-        AcceptHandler, void(error_code)>::result_type
-#endif
     async_accept_ex(ResponseDecorator const& decorator,
         AcceptHandler&& handler);
 
@@ -1087,12 +1079,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class ConstBufferSequence, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept(ConstBufferSequence const& buffers,
         AcceptHandler&& handler);
 
@@ -1155,12 +1143,8 @@ public:
     */
     template<class ConstBufferSequence,
         class ResponseDecorator, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept_ex(ConstBufferSequence const& buffers,
         ResponseDecorator const& decorator,
             AcceptHandler&& handler);
@@ -1211,12 +1195,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class Fields, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept(http::header<true, Fields> const& req,
         AcceptHandler&& handler);
 
@@ -1276,12 +1256,8 @@ public:
     */
     template<class Fields,
         class ResponseDecorator, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept_ex(http::header<true, Fields> const& req,
         ResponseDecorator const& decorator,
             AcceptHandler&& handler);
@@ -1340,12 +1316,8 @@ public:
     */
     template<class Fields,
         class ConstBufferSequence, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept(http::header<true, Fields> const& req,
         ConstBufferSequence const& buffers,
             AcceptHandler&& handler);
@@ -1413,12 +1385,8 @@ public:
     */
     template<class Fields, class ConstBufferSequence,
         class ResponseDecorator, class AcceptHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        AcceptHandler, void(error_code))
-#else
-    typename async_completion<AcceptHandler,
-        void(error_code)>::result_type
-#endif
     async_accept_ex(http::header<true, Fields> const& req,
         ConstBufferSequence const& buffers,
             ResponseDecorator const& decorator,
@@ -1895,12 +1863,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class HandshakeHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        HandshakeHandler, void(error_code))
-#else
-    typename async_completion<HandshakeHandler,
-        void(error_code)>::result_type
-#endif
     async_handshake(string_view const& host,
         string_view const& target,
             HandshakeHandler&& handler);
@@ -1951,12 +1915,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class HandshakeHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        HandshakeHandler, void(error_code))
-#else
-    typename async_completion<HandshakeHandler,
-        void(error_code)>::result_type
-#endif
     async_handshake(response_type& res,
         string_view const& host,
             string_view const& target,
@@ -2013,12 +1973,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class RequestDecorator, class HandshakeHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        HandshakeHandler, void(error_code))
-#else
-    typename async_completion<HandshakeHandler,
-        void(error_code)>::result_type
-#endif
     async_handshake_ex(string_view const& host,
         string_view const& target,
             RequestDecorator const& decorator,
@@ -2079,12 +2035,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class RequestDecorator, class HandshakeHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        HandshakeHandler, void(error_code))
-#else
-    typename async_completion<HandshakeHandler,
-        void(error_code)>::result_type
-#endif
     async_handshake_ex(response_type& res,
         string_view const& host,
             string_view const& target,
@@ -2193,12 +2145,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class CloseHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        CloseHandler, void(error_code))
-#else
-    typename async_completion<
-        CloseHandler, void(error_code)>::result_type
-#endif
     async_close(close_reason const& cr, CloseHandler&& handler);
 
     /** Send a WebSocket ping frame.
@@ -2275,12 +2223,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class WriteHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        WriteHandler, void(error_code))
-#else
-    typename async_completion<
-        WriteHandler, void(error_code)>::result_type
-#endif
     async_ping(ping_data const& payload, WriteHandler&& handler);
 
     /** Send a WebSocket pong frame.
@@ -2372,12 +2316,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class WriteHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        WriteHandler, void(error_code))
-#else
-    typename async_completion<
-        WriteHandler, void(error_code)>::result_type
-#endif
     async_pong(ping_data const& payload, WriteHandler&& handler);
 
     /** Read a message from the stream.
@@ -2520,12 +2460,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class DynamicBuffer, class ReadHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        ReadHandler, void(error_code))
-#else
-    typename async_completion<
-        ReadHandler, void(error_code)>::result_type
-#endif
     async_read(opcode& op, DynamicBuffer& dynabuf, ReadHandler&& handler);
 
     /** Read a message frame from the stream.
@@ -2678,12 +2614,8 @@ public:
         manner equivalent to using boost::asio::io_service::post().
     */
     template<class DynamicBuffer, class ReadHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        ReadHandler, void(error_code))
-#else
-    typename async_completion<
-        ReadHandler, void(error_code)>::result_type
-#endif
     async_read_frame(frame_info& fi,
         DynamicBuffer& dynabuf, ReadHandler&& handler);
 
@@ -2804,12 +2736,8 @@ public:
         manner equivalent to using `boost::asio::io_service::post`.
     */
     template<class ConstBufferSequence, class WriteHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        WriteHandler, void(error_code))
-#else
-    typename async_completion<
-        WriteHandler, void(error_code)>::result_type
-#endif
     async_write(ConstBufferSequence const& buffers,
         WriteHandler&& handler);
 
@@ -2920,12 +2848,8 @@ public:
         ); @endcode
     */
     template<class ConstBufferSequence, class WriteHandler>
-#if BEAST_DOXYGEN
+    BEAST_INITFN_RESULT_TYPE(
-    void_or_deduced
+        WriteHandler, void(error_code))
-#else
-    typename async_completion<
-        WriteHandler, void(error_code)>::result_type
-#endif
     async_write_frame(bool fin,
         ConstBufferSequence const& buffers, WriteHandler&& handler);
 

test/Jamfile

@@ -16,7 +16,7 @@ compile zlib.cpp : : ;
 
 unit-test core-tests :
     ../extras/beast/unit_test/main.cpp
-    core/async_completion.cpp
+    core/async_result.cpp
     core/bind_handler.cpp
     core/buffer_cat.cpp
     core/buffer_concepts.cpp

test/core/CMakeLists.txt

@@ -9,7 +9,7 @@ add_executable (core-tests
     ${EXTRAS_INCLUDES}
     ../../extras/beast/unit_test/main.cpp
     buffer_test.hpp
-    async_completion.cpp
+    async_result.cpp
     bind_handler.cpp
     buffer_cat.cpp
     buffer_concepts.cpp

test/core/async_result.cpp

@@ -6,4 +6,4 @@
 //
 
 // Test that header file is self-contained.
-#include <beast/core/async_completion.hpp>
+#include <beast/core/async_result.hpp>

test/core/buffer_concepts.cpp

@@ -16,10 +16,10 @@ struct T
 };
 }
 
-static_assert(is_ConstBufferSequence<detail::ConstBufferSequence>::value, "");
+static_assert(is_const_buffer_sequence<detail::ConstBufferSequence>::value, "");
-static_assert(! is_ConstBufferSequence<T>::value, "");
+static_assert(! is_const_buffer_sequence<T>::value, "");
 
-static_assert(is_MutableBufferSequence<detail::MutableBufferSequence>::value, "");
+static_assert(is_mutable_buffer_sequence<detail::MutableBufferSequence>::value, "");
-static_assert(! is_MutableBufferSequence<T>::value, "");
+static_assert(! is_mutable_buffer_sequence<T>::value, "");
 
 } // beast

test/core/buffer_test.hpp

@@ -18,7 +18,7 @@ namespace test {
 
 template<class ConstBufferSequence>
 typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
+    is_const_buffer_sequence<ConstBufferSequence>::value,
         std::size_t>::type
 buffer_count(ConstBufferSequence const& buffers)
 {
@@ -27,7 +27,7 @@ buffer_count(ConstBufferSequence const& buffers)
 
 template<class ConstBufferSequence>
 typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
+    is_const_buffer_sequence<ConstBufferSequence>::value,
         std::size_t>::type
 size_pre(ConstBufferSequence const& buffers)
 {
@@ -46,7 +46,7 @@ size_pre(ConstBufferSequence const& buffers)
 
 template<class ConstBufferSequence>
 typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
+    is_const_buffer_sequence<ConstBufferSequence>::value,
         std::size_t>::type
 size_post(ConstBufferSequence const& buffers)
 {
@@ -58,7 +58,7 @@ size_post(ConstBufferSequence const& buffers)
 
 template<class ConstBufferSequence>
 typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
+    is_const_buffer_sequence<ConstBufferSequence>::value,
         std::size_t>::type
 size_rev_pre(ConstBufferSequence const& buffers)
 {
@@ -70,7 +70,7 @@ size_rev_pre(ConstBufferSequence const& buffers)
 
 template<class ConstBufferSequence>
 typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
+    is_const_buffer_sequence<ConstBufferSequence>::value,
         std::size_t>::type
 size_rev_post(ConstBufferSequence const& buffers)
 {

test/core/flat_buffer.cpp

@@ -17,7 +17,7 @@
 
 namespace beast {
 
-static_assert(is_DynamicBuffer<flat_buffer>::value,
+static_assert(is_dynamic_buffer<flat_buffer>::value,
     "DynamicBuffer requirements not met");
 
 class flat_buffer_test : public beast::unit_test::suite

test/core/multi_buffer.cpp

@@ -21,7 +21,7 @@
 
 namespace beast {
 
-static_assert(is_DynamicBuffer<multi_buffer>::value, "");
+static_assert(is_dynamic_buffer<multi_buffer>::value, "");
 
 class multi_buffer_test : public beast::unit_test::suite
 {

test/http/nodejs_parser.hpp

@@ -482,7 +482,7 @@ std::size_t
 nodejs_basic_parser<Derived>::write(
     ConstBufferSequence const& buffers, error_code& ec)
 {
-    static_assert(beast::is_ConstBufferSequence<
+    static_assert(beast::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     using boost::asio::buffer_cast;