diff --git a/example/common/detect_ssl.hpp b/example/common/detect_ssl.hpp
index a91c7988..cc25b8e7 100644
--- a/example/common/detect_ssl.hpp
+++ b/example/common/detect_ssl.hpp
@@ -65,7 +65,7 @@ is_ssl_handshake(
     // Make sure buffers meets the requirements
     static_assert(
         boost::asio::is_const_buffer_sequence<ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
 
     // Extract the first byte, which holds the
     // "message" type for the Handshake protocol.
@@ -137,10 +137,10 @@ detect_ssl(
 
     // Make sure arguments meet the requirements
     static_assert(beast::is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     // Loop until an error occurs or we get a definitive answer
     for(;;)
@@ -267,10 +267,10 @@ async_detect_ssl(
 
     // Make sure arguments meet the requirements
     static_assert(beast::is_async_read_stream<AsyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     // This helper manages some of the handler's lifetime and
     // uses the result and handler specializations associated with
diff --git a/example/echo-op/echo_op.cpp b/example/echo-op/echo_op.cpp
index 44b0d2d6..2230e5c0 100644
--- a/example/echo-op/echo_op.cpp
+++ b/example/echo-op/echo_op.cpp
@@ -120,10 +120,10 @@ async_echo(
     // with more friendly error messages when passing the wrong types.
     static_assert(
         beast::is_async_stream<AsyncStream>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     // This class template deduces the actual handler type from a
     // CompletionToken, captures a local reference to the handler,
diff --git a/include/boost/beast/_experimental/http/impl/icy_stream.hpp b/include/boost/beast/_experimental/http/impl/icy_stream.hpp
index 368c3ceb..7e72dcf7 100644
--- a/include/boost/beast/_experimental/http/impl/icy_stream.hpp
+++ b/include/boost/beast/_experimental/http/impl/icy_stream.hpp
@@ -306,10 +306,10 @@ icy_stream<NextLayer>::
 read_some(MutableBufferSequence const& buffers)
 {
     static_assert(is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     error_code ec;
     auto n = read_some(buffers, ec);
     if(ec)
@@ -324,10 +324,10 @@ icy_stream<NextLayer>::
 read_some(MutableBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     using iterator = net::buffers_iterator<
         typename beast::dynamic_buffer_ref_wrapper<
             buffers_adaptor<MutableBufferSequence>>::const_buffers_type>;
@@ -445,10 +445,10 @@ async_read_some(
     ReadHandler&& handler)
 {
     static_assert(is_async_read_stream<next_layer_type>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence >::value,
-        "MutableBufferSequence  requirements not met");
+        "MutableBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     read_op<
@@ -466,10 +466,10 @@ icy_stream<NextLayer>::
 write_some(MutableBufferSequence const& buffers)
 {
     static_assert(is_sync_write_stream<next_layer_type>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     return stream_.write_some(buffers);
 }
 
@@ -480,10 +480,10 @@ icy_stream<NextLayer>::
 write_some(MutableBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_sync_write_stream<next_layer_type>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     return stream_.write_some(buffers, ec);
 }
 
@@ -499,10 +499,10 @@ async_write_some(
     WriteHandler&& handler)
 {
     static_assert(is_async_write_stream<next_layer_type>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     return stream_.async_write_some(
         buffers, std::forward<WriteHandler>(handler));
 }
diff --git a/include/boost/beast/_experimental/test/impl/stream.hpp b/include/boost/beast/_experimental/test/impl/stream.hpp
index a916bf78..c31f101f 100644
--- a/include/boost/beast/_experimental/test/impl/stream.hpp
+++ b/include/boost/beast/_experimental/test/impl/stream.hpp
@@ -308,7 +308,7 @@ read_some(MutableBufferSequence const& buffers)
 {
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     error_code ec;
     auto const n = read_some(buffers, ec);
     if(ec)
@@ -324,7 +324,7 @@ read_some(MutableBufferSequence const& buffers,
 {
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
 
     ++in_->nread;
 
@@ -374,7 +374,7 @@ async_read_some(
 {
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
 
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
@@ -453,7 +453,7 @@ write_some(ConstBufferSequence const& buffers)
 {
     static_assert(net::is_const_buffer_sequence<
             ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write_some(buffers, ec);
@@ -470,7 +470,7 @@ write_some(
 {
     static_assert(net::is_const_buffer_sequence<
             ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
 
     ++in_->nwrite;
 
@@ -514,7 +514,7 @@ async_write_some(ConstBufferSequence const& buffers,
 {
     static_assert(net::is_const_buffer_sequence<
             ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
 
diff --git a/include/boost/beast/core/async_op_base.hpp b/include/boost/beast/core/async_op_base.hpp
index d2748d18..f4b64dbf 100644
--- a/include/boost/beast/core/async_op_base.hpp
+++ b/include/boost/beast/core/async_op_base.hpp
@@ -183,7 +183,7 @@ class async_op_base
 {
     static_assert(
         net::is_executor<Executor1>::value,
-        "Executor requirements not met");
+        "Executor type requirements not met");
 
     Handler h_;
     net::executor_work_guard<Executor1> wg1_;
diff --git a/include/boost/beast/core/basic_stream.hpp b/include/boost/beast/core/basic_stream.hpp
index 41296285..4f8b9221 100644
--- a/include/boost/beast/core/basic_stream.hpp
+++ b/include/boost/beast/core/basic_stream.hpp
@@ -222,7 +222,7 @@ public:
 
 private:
     static_assert(net::is_executor<Executor>::value,
-        "Executor requirements not met");
+        "Executor type requirements not met");
 
     struct impl_type
         : boost::enable_shared_from_this<impl_type>
diff --git a/include/boost/beast/core/buffer_traits.hpp b/include/boost/beast/core/buffer_traits.hpp
index 5f69043d..84ae7e1a 100644
--- a/include/boost/beast/core/buffer_traits.hpp
+++ b/include/boost/beast/core/buffer_traits.hpp
@@ -83,7 +83,7 @@ using is_mutable_buffer_sequence = mp11::mp_all<
     {
         static_assert(
             net::is_const_buffer_sequence<BufferSequence>::value,
-            "BufferSequence requirements not met");
+            "BufferSequence type requirements not met");
         auto const first = net::buffer_sequence_begin (buffers);
         if (first == net::buffer_sequence_end (buffers))
             return {};
diff --git a/include/boost/beast/core/buffered_read_stream.hpp b/include/boost/beast/core/buffered_read_stream.hpp
index fc7a47bb..4c3dfed4 100644
--- a/include/boost/beast/core/buffered_read_stream.hpp
+++ b/include/boost/beast/core/buffered_read_stream.hpp
@@ -93,7 +93,7 @@ class buffered_read_stream
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     template<class Buffers, class Handler>
     class read_some_op;
@@ -286,7 +286,7 @@ public:
     write_some(ConstBufferSequence const& buffers)
     {
         static_assert(is_sync_write_stream<next_layer_type>::value,
-            "SyncWriteStream requirements not met");
+            "SyncWriteStream type requirements not met");
         return next_layer_.write_some(buffers);
     }
 
@@ -308,7 +308,7 @@ public:
         error_code& ec)
     {
         static_assert(is_sync_write_stream<next_layer_type>::value,
-            "SyncWriteStream requirements not met");
+            "SyncWriteStream type requirements not met");
         return next_layer_.write_some(buffers, ec);
     }
 
diff --git a/include/boost/beast/core/buffers_adaptor.hpp b/include/boost/beast/core/buffers_adaptor.hpp
index 46b30d6e..9f8826e7 100644
--- a/include/boost/beast/core/buffers_adaptor.hpp
+++ b/include/boost/beast/core/buffers_adaptor.hpp
@@ -37,7 +37,7 @@ class buffers_adaptor
 {
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
 
     using iter_type =
         buffers_iterator_type<MutableBufferSequence>;
diff --git a/include/boost/beast/core/buffers_cat.hpp b/include/boost/beast/core/buffers_cat.hpp
index 7cb778bd..a5389cc5 100644
--- a/include/boost/beast/core/buffers_cat.hpp
+++ b/include/boost/beast/core/buffers_cat.hpp
@@ -99,7 +99,7 @@ buffers_cat(B1 const& b1, B2 const& b2, Bn const&... bn)
 {
     static_assert(
         is_const_buffer_sequence<B1, B2, Bn...>::value,
-        "BufferSequence requirements not met");
+        "BufferSequence type requirements not met");
     return buffers_cat_view<B1, B2, Bn...>{b1, b2, bn...};
 }
 
diff --git a/include/boost/beast/core/buffers_prefix.hpp b/include/boost/beast/core/buffers_prefix.hpp
index 87d60c0f..1269f6c0 100644
--- a/include/boost/beast/core/buffers_prefix.hpp
+++ b/include/boost/beast/core/buffers_prefix.hpp
@@ -169,7 +169,7 @@ buffers_prefix(
 {
     static_assert(
         net::is_const_buffer_sequence<BufferSequence>::value,
-            "BufferSequence requirements not met");
+            "BufferSequence type requirements not met");
     return buffers_prefix_view<BufferSequence>(size, buffers);
 }
 
diff --git a/include/boost/beast/core/buffers_range.hpp b/include/boost/beast/core/buffers_range.hpp
index cdc40768..bdea8b98 100644
--- a/include/boost/beast/core/buffers_range.hpp
+++ b/include/boost/beast/core/buffers_range.hpp
@@ -63,7 +63,7 @@ buffers_range(BufferSequence const& buffers)
 {
     static_assert(
         is_const_buffer_sequence<BufferSequence>::value,
-        "BufferSequence requirements not met");
+        "BufferSequence type requirements not met");
     return detail::buffers_range_adaptor<
         BufferSequence>(buffers);
 }
@@ -116,7 +116,7 @@ buffers_range_ref(BufferSequence const& buffers)
 {
     static_assert(
         is_const_buffer_sequence<BufferSequence>::value,
-        "BufferSequence requirements not met");
+        "BufferSequence type requirements not met");
     return detail::buffers_range_adaptor<
         BufferSequence const&>(buffers);
 }
diff --git a/include/boost/beast/core/buffers_to_string.hpp b/include/boost/beast/core/buffers_to_string.hpp
index 0d93e312..22599c0c 100644
--- a/include/boost/beast/core/buffers_to_string.hpp
+++ b/include/boost/beast/core/buffers_to_string.hpp
@@ -47,7 +47,7 @@ buffers_to_string(ConstBufferSequence const& buffers)
 {
     static_assert(
         net::is_const_buffer_sequence<ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     std::string result;
     result.reserve(buffer_size(buffers));
     for(auto const buffer : buffers_range_ref(buffers))
diff --git a/include/boost/beast/core/detail/buffers_ref.hpp b/include/boost/beast/core/detail/buffers_ref.hpp
index a2a61166..4debb48f 100644
--- a/include/boost/beast/core/detail/buffers_ref.hpp
+++ b/include/boost/beast/core/detail/buffers_ref.hpp
@@ -60,7 +60,7 @@ make_buffers_ref(BufferSequence const& buffers)
 {
     static_assert(
         is_const_buffer_sequence<BufferSequence>::value,
-        "BufferSequence requirements not met");
+        "BufferSequence type requirements not met");
     return buffers_ref<BufferSequence>(buffers);
 }
 
diff --git a/include/boost/beast/core/detail/impl/read.hpp b/include/boost/beast/core/detail/impl/read.hpp
index 66bab82a..84121034 100644
--- a/include/boost/beast/core/detail/impl/read.hpp
+++ b/include/boost/beast/core/detail/impl/read.hpp
@@ -215,14 +215,14 @@ async_read(
     ReadHandler&& handler)
 {
     static_assert(is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(
         detail::is_invocable<CompletionCondition,
             void(error_code&, std::size_t, DynamicBuffer&)>::value,
-        "CompletionCondition requirements not met");
+        "CompletionCondition type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     detail::read_op<
@@ -252,11 +252,11 @@ async_read(
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(
         detail::is_invocable<CompletionCondition,
             void(error_code&, std::size_t, DynamicBuffer&)>::value,
-        "CompletionCondition requirements not met");
+        "CompletionCondition type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     if(socket.non_blocking())
@@ -299,14 +299,14 @@ read(
     CompletionCondition cond)
 {
     static_assert(is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(
         detail::is_invocable<CompletionCondition,
             void(error_code&, std::size_t, DynamicBuffer&)>::value,
-        "CompletionCondition requirements not met");
+        "CompletionCondition type requirements not met");
     error_code ec;
     auto const bytes_transferred = detail::read(
         stream, buffer, std::move(cond), ec);
@@ -328,14 +328,14 @@ read(
     error_code& ec)
 {
     static_assert(is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(
         detail::is_invocable<CompletionCondition,
             void(error_code&, std::size_t, DynamicBuffer&)>::value,
-        "CompletionCondition requirements not met");
+        "CompletionCondition type requirements not met");
     ec = {};
     std::size_t total = 0;
     std::size_t max_size;
@@ -372,11 +372,11 @@ read(
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(
         detail::is_invocable<CompletionCondition,
             void(error_code&, std::size_t, DynamicBuffer&)>::value,
-        "CompletionCondition requirements not met");
+        "CompletionCondition type requirements not met");
     ec = {};
     std::size_t n;
     std::size_t limit;
diff --git a/include/boost/beast/core/dynamic_buffer_ref.hpp b/include/boost/beast/core/dynamic_buffer_ref.hpp
index 03b33e7a..e1d892d5 100644
--- a/include/boost/beast/core/dynamic_buffer_ref.hpp
+++ b/include/boost/beast/core/dynamic_buffer_ref.hpp
@@ -30,7 +30,7 @@ class dynamic_buffer_ref_wrapper
 #if ! BOOST_BEAST_DOXYGEN
 {
     static_assert(net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     DynamicBuffer& b_;
 
@@ -133,7 +133,7 @@ dynamic_buffer_ref_wrapper<DynamicBuffer>
 dynamic_buffer_ref(DynamicBuffer& buffer) noexcept
 {
     static_assert(net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     return dynamic_buffer_ref_wrapper<DynamicBuffer>(buffer);
 }
 
diff --git a/include/boost/beast/core/file_base.hpp b/include/boost/beast/core/file_base.hpp
index f05afce4..9229aa7a 100644
--- a/include/boost/beast/core/file_base.hpp
+++ b/include/boost/beast/core/file_base.hpp
@@ -110,7 +110,7 @@ enum class file_mode
     void f(File& file)
     {
         static_assert(is_file<File>::value,
-            "File requirements not met");
+            "File type requirements not met");
     ...
     @endcode
 
diff --git a/include/boost/beast/core/impl/basic_stream.hpp b/include/boost/beast/core/impl/basic_stream.hpp
index 3c1d56ea..18699e7a 100644
--- a/include/boost/beast/core/impl/basic_stream.hpp
+++ b/include/boost/beast/core/impl/basic_stream.hpp
@@ -911,7 +911,7 @@ async_read_some(
 {
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
@@ -932,7 +932,7 @@ async_write_some(
 {
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
diff --git a/include/boost/beast/core/impl/buffered_read_stream.hpp b/include/boost/beast/core/impl/buffered_read_stream.hpp
index 97c97b2f..805ce9c0 100644
--- a/include/boost/beast/core/impl/buffered_read_stream.hpp
+++ b/include/boost/beast/core/impl/buffered_read_stream.hpp
@@ -119,13 +119,13 @@ async_write_some(
     WriteHandler&& handler)
 {
     static_assert(is_async_write_stream<next_layer_type>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     static_assert(detail::is_invocable<WriteHandler,
         void(error_code, std::size_t)>::value,
-            "WriteHandler requirements not met");
+            "WriteHandler type requirements not met");
     return next_layer_.async_write_some(buffers,
         std::forward<WriteHandler>(handler));
 }
@@ -138,10 +138,10 @@ read_some(
     MutableBufferSequence const& buffers)
 {
     static_assert(is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     error_code ec;
     auto n = read_some(buffers, ec);
     if(ec)
@@ -157,10 +157,10 @@ read_some(MutableBufferSequence const& buffers,
     error_code& ec)
 {
     static_assert(is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     if(buffer_.size() == 0)
     {
         if(capacity_ == 0)
@@ -191,10 +191,10 @@ async_read_some(
     ReadHandler&& handler)
 {
     static_assert(is_async_read_stream<next_layer_type>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-            "MutableBufferSequence requirements not met");
+            "MutableBufferSequence type requirements not met");
     if(buffer_.size() == 0 && capacity_ == 0)
         return next_layer_.async_read_some(buffers,
             std::forward<ReadHandler>(handler));
diff --git a/include/boost/beast/core/impl/buffers_suffix.hpp b/include/boost/beast/core/impl/buffers_suffix.hpp
index 8f6775a3..a8c02472 100644
--- a/include/boost/beast/core/impl/buffers_suffix.hpp
+++ b/include/boost/beast/core/impl/buffers_suffix.hpp
@@ -146,7 +146,7 @@ buffers_suffix(Buffers const& bs)
     static_assert(
         net::is_const_buffer_sequence<Buffers>::value ||
         net::is_mutable_buffer_sequence<Buffers>::value,
-            "BufferSequence requirements not met");
+            "BufferSequence type requirements not met");
 }
 
 template<class Buffers>
diff --git a/include/boost/beast/core/impl/flat_stream.hpp b/include/boost/beast/core/impl/flat_stream.hpp
index dcdee697..734b199c 100644
--- a/include/boost/beast/core/impl/flat_stream.hpp
+++ b/include/boost/beast/core/impl/flat_stream.hpp
@@ -89,10 +89,10 @@ flat_stream<NextLayer>::
 read_some(MutableBufferSequence const& buffers)
 {
     static_assert(boost::beast::is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     error_code ec;
     auto n = read_some(buffers, ec);
     if(ec)
@@ -107,10 +107,10 @@ flat_stream<NextLayer>::
 read_some(MutableBufferSequence const& buffers, error_code& ec)
 {
     static_assert(boost::beast::is_sync_read_stream<next_layer_type>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     return stream_.read_some(buffers, ec);
 }
 
@@ -126,10 +126,10 @@ async_read_some(
     ReadHandler&& handler)
 {
     static_assert(boost::beast::is_async_read_stream<next_layer_type>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
         MutableBufferSequence >::value,
-        "MutableBufferSequence  requirements not met");
+        "MutableBufferSequence type requirements not met");
     return stream_.async_read_some(
         buffers, std::forward<ReadHandler>(handler));
 }
@@ -141,10 +141,10 @@ flat_stream<NextLayer>::
 write_some(ConstBufferSequence const& buffers)
 {
     static_assert(boost::beast::is_sync_write_stream<next_layer_type>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     error_code ec;
     auto n = write_some(buffers, ec);
     if(ec)
@@ -174,10 +174,10 @@ flat_stream<NextLayer>::
 write_some(ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(boost::beast::is_sync_write_stream<next_layer_type>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     auto const result = flatten(buffers, max_size);
     if(result.flatten)
     {
@@ -208,10 +208,10 @@ async_write_some(
     WriteHandler&& handler)
 {
     static_assert(boost::beast::is_async_write_stream<next_layer_type>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
     write_op<BOOST_ASIO_HANDLER_TYPE(
diff --git a/include/boost/beast/core/impl/read_size.hpp b/include/boost/beast/core/impl/read_size.hpp
index d360210b..6a0ac768 100644
--- a/include/boost/beast/core/impl/read_size.hpp
+++ b/include/boost/beast/core/impl/read_size.hpp
@@ -45,7 +45,7 @@ read_size(DynamicBuffer& buffer,
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_ASSERT(max_size >= 1);
     auto const size = buffer.size();
     auto const limit = buffer.max_size() - size;
diff --git a/include/boost/beast/core/make_printable.hpp b/include/boost/beast/core/make_printable.hpp
index ea9fa9cb..1f1f2736 100644
--- a/include/boost/beast/core/make_printable.hpp
+++ b/include/boost/beast/core/make_printable.hpp
@@ -96,7 +96,7 @@ make_printable(ConstBufferSequence const& buffers)
 {
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     return detail::make_printable_adaptor<
         ConstBufferSequence>{buffers};
 }
diff --git a/include/boost/beast/core/multi_buffer.hpp b/include/boost/beast/core/multi_buffer.hpp
index 64b4aeb2..631f2636 100644
--- a/include/boost/beast/core/multi_buffer.hpp
+++ b/include/boost/beast/core/multi_buffer.hpp
@@ -99,11 +99,11 @@ class basic_multi_buffer
 
     static_assert(std::is_base_of<std::bidirectional_iterator_tag,
         typename std::iterator_traits<iter>::iterator_category>::value,
-            "BidirectionalIterator requirements not met");
+            "BidirectionalIterator type requirements not met");
 
     static_assert(std::is_base_of<std::bidirectional_iterator_tag,
         typename std::iterator_traits<const_iter>::iterator_category>::value,
-            "BidirectionalIterator requirements not met");
+            "BidirectionalIterator type requirements not met");
 
     std::size_t max_;
     list_type list_;        // list of allocated buffers
diff --git a/include/boost/beast/core/ostream.hpp b/include/boost/beast/core/ostream.hpp
index 852ce6eb..5b8392f1 100644
--- a/include/boost/beast/core/ostream.hpp
+++ b/include/boost/beast/core/ostream.hpp
@@ -59,7 +59,7 @@ ostream(DynamicBuffer& buffer)
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     return detail::ostream_helper<
         DynamicBuffer, char, std::char_traits<char>,
             detail::basic_streambuf_movable::value>{buffer};
diff --git a/include/boost/beast/core/stream_traits.hpp b/include/boost/beast/core/stream_traits.hpp
index f1815953..e5b0ceee 100644
--- a/include/boost/beast/core/stream_traits.hpp
+++ b/include/boost/beast/core/stream_traits.hpp
@@ -190,7 +190,7 @@ struct has_get_executor<T, boost::void_t<decltype(
     void f(SyncReadStream& stream)
     {
         static_assert(is_sync_read_stream<SyncReadStream>::value,
-            "SyncReadStream requirements not met");
+            "SyncReadStream type requirements not met");
     ...
     @endcode
 
@@ -234,7 +234,7 @@ struct is_sync_read_stream<T, boost::void_t<decltype(
     void f(SyncReadStream& stream)
     {
         static_assert(is_sync_read_stream<SyncReadStream>::value,
-            "SyncReadStream requirements not met");
+            "SyncReadStream type requirements not met");
     ...
     @endcode
 
@@ -279,7 +279,7 @@ struct is_sync_write_stream<T, boost::void_t<decltype(
     void f(SyncStream& stream)
     {
         static_assert(is_sync_stream<SyncStream>::value,
-            "SyncStream requirements not met");
+            "SyncStream type requirements not met");
     ...
     @endcode
 
@@ -317,7 +317,7 @@ using is_sync_stream = std::integral_constant<bool,
     void f(AsyncReadStream& stream)
     {
         static_assert(is_async_read_stream<AsyncReadStream>::value,
-            "AsyncReadStream requirements not met");
+            "AsyncReadStream type requirements not met");
     ...
     @endcode
     
@@ -361,7 +361,7 @@ struct is_async_read_stream<T, boost::void_t<decltype(
     void f(AsyncWriteStream& stream)
     {
         static_assert(is_async_write_stream<AsyncWriteStream>::value,
-            "AsyncWriteStream requirements not met");
+            "AsyncWriteStream type requirements not met");
     ...
     @endcode
 
@@ -405,7 +405,7 @@ struct is_async_write_stream<T, boost::void_t<decltype(
     void f(AsyncStream& stream)
     {
         static_assert(is_async_stream<AsyncStream>::value,
-            "AsyncStream requirements not met");
+            "AsyncStream type requirements not met");
     ...
     @endcode
 
diff --git a/include/boost/beast/http/basic_dynamic_body.hpp b/include/boost/beast/http/basic_dynamic_body.hpp
index eb65b9e4..5eac2d4f 100644
--- a/include/boost/beast/http/basic_dynamic_body.hpp
+++ b/include/boost/beast/http/basic_dynamic_body.hpp
@@ -35,7 +35,7 @@ struct basic_dynamic_body
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
 
     /** The type of container used for the body
 
diff --git a/include/boost/beast/http/basic_file_body.hpp b/include/boost/beast/http/basic_file_body.hpp
index 5fab105d..aef68768 100644
--- a/include/boost/beast/http/basic_file_body.hpp
+++ b/include/boost/beast/http/basic_file_body.hpp
@@ -45,7 +45,7 @@ struct basic_file_body
 {
     // Make sure the type meets the requirements
     static_assert(is_file<File>::value,
-        "File requirements not met");
+        "File type requirements not met");
 
     /// The type of File this body uses
     using file_type = File;
diff --git a/include/boost/beast/http/impl/basic_parser.ipp b/include/boost/beast/http/impl/basic_parser.ipp
index 9404ca77..d2df45bd 100644
--- a/include/boost/beast/http/impl/basic_parser.ipp
+++ b/include/boost/beast/http/impl/basic_parser.ipp
@@ -93,7 +93,7 @@ put(ConstBufferSequence const& buffers,
 {
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     auto const p = net::buffer_sequence_begin(buffers);
     auto const last = net::buffer_sequence_end(buffers);
     if(p == last)
diff --git a/include/boost/beast/http/impl/read.ipp b/include/boost/beast/http/impl/read.ipp
index 38058a6b..3cc9c0bf 100644
--- a/include/boost/beast/http/impl/read.ipp
+++ b/include/boost/beast/http/impl/read.ipp
@@ -219,10 +219,10 @@ read_some(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         read_some(stream, buffer, parser, ec);
@@ -244,10 +244,10 @@ read_some(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     return beast::detail::read(stream, buffer,
         detail::read_some_condition<
             isRequest, Derived>{parser}, ec);
@@ -268,10 +268,10 @@ async_read_some(
 {
     static_assert(
         is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     beast::detail::async_read(stream, buffer,
@@ -295,10 +295,10 @@ read_header(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         read_header(stream, buffer, parser, ec);
@@ -320,10 +320,10 @@ read_header(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     parser.eager(false);
     return beast::detail::read(stream, buffer,
         detail::read_header_condition<
@@ -345,10 +345,10 @@ async_read_header(
 {
     static_assert(
         is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     parser.eager(false);
@@ -373,10 +373,10 @@ read(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         read(stream, buffer, parser, ec);
@@ -398,10 +398,10 @@ read(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     parser.eager(true);
     return beast::detail::read(stream, buffer,
         detail::read_all_condition<
@@ -423,10 +423,10 @@ async_read(
 {
     static_assert(
         is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     parser.eager(true);
@@ -451,14 +451,14 @@ read(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_reader<Body>::value,
-        "BodyReader requirements not met");
+        "BodyReader type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         read(stream, buffer, msg, ec);
@@ -480,14 +480,14 @@ read(
 {
     static_assert(
         is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_reader<Body>::value,
-        "BodyReader requirements not met");
+        "BodyReader type requirements not met");
     parser<isRequest, Body, Allocator> p(std::move(msg));
     p.eager(true);
     auto const bytes_transferred =
@@ -513,14 +513,14 @@ async_read(
 {
     static_assert(
         is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream requirements not met");
+        "AsyncReadStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_reader<Body>::value,
-        "BodyReader requirements not met");
+        "BodyReader type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     detail::read_msg_op<
diff --git a/include/boost/beast/http/impl/write.ipp b/include/boost/beast/http/impl/write.ipp
index 25a78206..15318f4e 100644
--- a/include/boost/beast/http/impl/write.ipp
+++ b/include/boost/beast/http/impl/write.ipp
@@ -365,11 +365,11 @@ write_some(
     serializer<isRequest, Body, Fields>& sr)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write_some(stream, sr, ec);
@@ -388,11 +388,11 @@ write_some(
     error_code& ec)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     return detail::write_some_impl(stream, sr, ec);
 }
 
@@ -409,11 +409,11 @@ async_write_some(
 {
     static_assert(is_async_write_stream<
             AsyncWriteStream>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     return detail::async_write_some_impl(stream, sr,
         std::forward<WriteHandler>(handler));
 }
@@ -428,11 +428,11 @@ write_header(SyncWriteStream& stream,
     serializer<isRequest, Body, Fields>& sr)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write_header(stream, sr, ec);
@@ -451,11 +451,11 @@ write_header(
     error_code& ec)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     sr.split(true);
     std::size_t bytes_transferred = 0;
     if(! sr.is_header_done())
@@ -492,11 +492,11 @@ async_write_header(
 {
     static_assert(is_async_write_stream<
             AsyncWriteStream>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     sr.split(true);
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
@@ -521,7 +521,7 @@ write(
     serializer<isRequest, Body, Fields>& sr)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write(stream, sr, ec);
@@ -540,7 +540,7 @@ write(
     error_code& ec)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     std::size_t bytes_transferred = 0;
     sr.split(false);
     for(;;)
@@ -568,11 +568,11 @@ async_write(
 {
     static_assert(is_async_write_stream<
             AsyncWriteStream>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     sr.split(false);
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
@@ -599,11 +599,11 @@ write(
     message<isRequest, Body, Fields>& msg)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write(stream, msg, ec);
@@ -623,11 +623,11 @@ write(
     message<isRequest, Body, Fields> const& msg)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write(stream, msg, ec);
@@ -648,11 +648,11 @@ write(
     error_code& ec)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     serializer<isRequest, Body, Fields> sr{msg};
     return write(stream, sr, ec);
 }
@@ -669,11 +669,11 @@ write(
     error_code& ec)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     serializer<isRequest, Body, Fields> sr{msg};
     return write(stream, sr, ec);
 }
@@ -693,11 +693,11 @@ async_write(
 {
     static_assert(
         is_async_write_stream<AsyncWriteStream>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
     detail::write_msg_op<
@@ -724,11 +724,11 @@ async_write(
 {
     static_assert(
         is_async_write_stream<AsyncWriteStream>::value,
-        "AsyncWriteStream requirements not met");
+        "AsyncWriteStream type requirements not met");
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
     detail::write_msg_op<
@@ -807,9 +807,9 @@ operator<<(std::ostream& os,
     message<isRequest, Body, Fields> const& msg)
 {
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
     serializer<isRequest, Body, Fields> sr{msg};
     error_code ec;
     detail::write_ostream_lambda<decltype(sr)> f{os, sr};
diff --git a/include/boost/beast/http/message.hpp b/include/boost/beast/http/message.hpp
index 1030bd0b..46d72ff8 100644
--- a/include/boost/beast/http/message.hpp
+++ b/include/boost/beast/http/message.hpp
@@ -59,7 +59,7 @@ class header<true, Fields> : public Fields
 {
 public:
     static_assert(is_fields<Fields>::value,
-        "Fields requirements not met");
+        "Fields type requirements not met");
 
     /// Indicates if the header is a request or response.
 #if BOOST_BEAST_DOXYGEN
@@ -263,7 +263,7 @@ class header<false, Fields> : public Fields
 {
 public:
     static_assert(is_fields<Fields>::value,
-        "Fields requirements not met");
+        "Fields type requirements not met");
 
     /// Indicates if the header is a request or response.
     using is_request = std::false_type;
@@ -896,7 +896,7 @@ public:
 
 private:
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
 
     template<
         class... BodyArgs,
diff --git a/include/boost/beast/http/parser.hpp b/include/boost/beast/http/parser.hpp
index 496b404a..bcd9f9a2 100644
--- a/include/boost/beast/http/parser.hpp
+++ b/include/boost/beast/http/parser.hpp
@@ -51,10 +51,10 @@ class parser
         parser<isRequest, Body, Allocator>>
 {
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
 
     static_assert(is_body_reader<Body>::value,
-        "BodyReader requirements not met");
+        "BodyReader type requirements not met");
 
     template<bool, class, class>
     friend class parser;
diff --git a/include/boost/beast/http/serializer.hpp b/include/boost/beast/http/serializer.hpp
index 73ad68f1..8ca1f2bc 100644
--- a/include/boost/beast/http/serializer.hpp
+++ b/include/boost/beast/http/serializer.hpp
@@ -57,10 +57,10 @@ class serializer
 {
 public:
     static_assert(is_body<Body>::value,
-        "Body requirements not met");
+        "Body type requirements not met");
 
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
 
     /** The type of message this serializer uses
 
diff --git a/include/boost/beast/http/type_traits.hpp b/include/boost/beast/http/type_traits.hpp
index cbe1751c..4e6baf20 100644
--- a/include/boost/beast/http/type_traits.hpp
+++ b/include/boost/beast/http/type_traits.hpp
@@ -39,7 +39,7 @@ class message;
     void check_body(message<isRequest, Body, Fields> const&)
     {
         static_assert(is_body<Body>::value,
-            "Body requirements not met");
+            "Body type requirements not met");
     }
     @endcode
 */
@@ -199,7 +199,7 @@ struct is_body_reader<T, beast::detail::void_t<decltype(
     void f(message<isRequest, Body, Fields> const&)
     {
         static_assert(is_fields<Fields>::value,
-            "Fields requirements not met");
+            "Fields type requirements not met");
     ...
     @endcode
 
diff --git a/include/boost/beast/websocket/detail/utf8_checker.hpp b/include/boost/beast/websocket/detail/utf8_checker.hpp
index ae37441e..53bb59ba 100644
--- a/include/boost/beast/websocket/detail/utf8_checker.hpp
+++ b/include/boost/beast/websocket/detail/utf8_checker.hpp
@@ -88,7 +88,7 @@ write(ConstBufferSequence const& buffers)
 {
     static_assert(
         net::is_const_buffer_sequence<ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
     for(auto b : beast::buffers_range_ref(buffers))
         if(! write(static_cast<
             std::uint8_t const*>(b.data()),
diff --git a/include/boost/beast/websocket/impl/accept.hpp b/include/boost/beast/websocket/impl/accept.hpp
index 5ee270d1..88fe2c77 100644
--- a/include/boost/beast/websocket/impl/accept.hpp
+++ b/include/boost/beast/websocket/impl/accept.hpp
@@ -391,7 +391,7 @@ stream<NextLayer, deflateSupported>::
 accept()
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     error_code ec;
     accept(ec);
     if(ec)
@@ -404,7 +404,7 @@ stream<NextLayer, deflateSupported>::
 accept(error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     do_accept(
         net::const_buffer{},
         &default_decorate_res, ec);
@@ -418,10 +418,10 @@ stream<NextLayer, deflateSupported>::
 accept(ConstBufferSequence const& buffers)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     error_code ec;
     accept(buffers, ec);
     if(ec)
@@ -436,10 +436,10 @@ accept(
     ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     do_accept(buffers, &default_decorate_res, ec);
 }
 
@@ -453,7 +453,7 @@ accept(
         http::basic_fields<Allocator>> const& req)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     error_code ec;
     accept(req, ec);
     if(ec)
@@ -470,7 +470,7 @@ accept(
     error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     impl_->reset();
     do_accept(req, &default_decorate_res, ec);
 }
@@ -487,7 +487,7 @@ async_accept(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         AcceptHandler, void(error_code));
     impl_->reset();
@@ -513,7 +513,7 @@ async_accept_ex(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -544,10 +544,10 @@ async_accept(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         AcceptHandler, void(error_code));
     impl_->reset();
@@ -576,10 +576,10 @@ async_accept_ex(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -607,7 +607,7 @@ async_accept(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         AcceptHandler, void(error_code));
     impl_->reset();
@@ -633,7 +633,7 @@ async_accept_ex(
     AcceptHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -661,7 +661,7 @@ accept_ex(ResponseDecorator const& decorator)
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -682,7 +682,7 @@ accept_ex(ResponseDecorator const& decorator, error_code& ec)
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -707,10 +707,10 @@ accept_ex(
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -737,13 +737,13 @@ accept_ex(
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     do_accept(buffers, decorator, ec);
 }
 
@@ -763,7 +763,7 @@ accept_ex(
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
@@ -790,7 +790,7 @@ accept_ex(
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
diff --git a/include/boost/beast/websocket/impl/close.hpp b/include/boost/beast/websocket/impl/close.hpp
index 16acb75b..884007d7 100644
--- a/include/boost/beast/websocket/impl/close.hpp
+++ b/include/boost/beast/websocket/impl/close.hpp
@@ -238,7 +238,7 @@ stream<NextLayer, deflateSupported>::
 close(close_reason const& cr)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     error_code ec;
     close(cr, ec);
     if(ec)
@@ -251,7 +251,7 @@ stream<NextLayer, deflateSupported>::
 close(close_reason const& cr, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     using beast::detail::clamp;
     auto& impl = *impl_;
     ec = {};
@@ -359,7 +359,7 @@ stream<NextLayer, deflateSupported>::
 async_close(close_reason const& cr, CloseHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         CloseHandler, void(error_code));
     close_op<BOOST_ASIO_HANDLER_TYPE(
diff --git a/include/boost/beast/websocket/impl/handshake.hpp b/include/boost/beast/websocket/impl/handshake.hpp
index 806445b0..a0d294e8 100644
--- a/include/boost/beast/websocket/impl/handshake.hpp
+++ b/include/boost/beast/websocket/impl/handshake.hpp
@@ -240,7 +240,7 @@ async_handshake(string_view host,
         HandshakeHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         HandshakeHandler, void(error_code));
     handshake_op<BOOST_ASIO_HANDLER_TYPE(
@@ -262,7 +262,7 @@ async_handshake(response_type& res,
             HandshakeHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         HandshakeHandler, void(error_code));
     handshake_op<BOOST_ASIO_HANDLER_TYPE(
@@ -280,7 +280,7 @@ handshake(string_view host,
     string_view target)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     error_code ec;
     handshake(
         host, target, ec);
@@ -296,7 +296,7 @@ handshake(response_type& res,
         string_view target)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     error_code ec;
     handshake(res, host, target, ec);
     if(ec)
@@ -310,7 +310,7 @@ handshake(string_view host,
     string_view target, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     do_handshake(nullptr,
         host, target, &default_decorate_req, ec);
 }
@@ -324,7 +324,7 @@ handshake(response_type& res,
             error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     do_handshake(&res,
         host, target, &default_decorate_req, ec);
 }
@@ -344,7 +344,7 @@ handshake_ex(string_view host,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
@@ -368,7 +368,7 @@ handshake_ex(response_type& res,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
@@ -392,7 +392,7 @@ handshake_ex(string_view host,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
@@ -415,7 +415,7 @@ handshake_ex(response_type& res,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
@@ -438,7 +438,7 @@ async_handshake_ex(string_view host,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
@@ -468,7 +468,7 @@ async_handshake_ex(response_type& res,
         BOOST_BEAST_DEPRECATION_STRING);
 #endif
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
diff --git a/include/boost/beast/websocket/impl/ping.hpp b/include/boost/beast/websocket/impl/ping.hpp
index 15c5eb3e..2e5b7223 100644
--- a/include/boost/beast/websocket/impl/ping.hpp
+++ b/include/boost/beast/websocket/impl/ping.hpp
@@ -262,7 +262,7 @@ stream<NextLayer, deflateSupported>::
 async_ping(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code));
     ping_op<BOOST_ASIO_HANDLER_TYPE(
@@ -280,7 +280,7 @@ stream<NextLayer, deflateSupported>::
 async_pong(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code));
     ping_op<BOOST_ASIO_HANDLER_TYPE(
diff --git a/include/boost/beast/websocket/impl/read.hpp b/include/boost/beast/websocket/impl/read.hpp
index f18525f4..2f13f221 100644
--- a/include/boost/beast/websocket/impl/read.hpp
+++ b/include/boost/beast/websocket/impl/read.hpp
@@ -698,10 +698,10 @@ stream<NextLayer, deflateSupported>::
 read(DynamicBuffer& buffer)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     error_code ec;
     auto const bytes_written = read(buffer, ec);
     if(ec)
@@ -716,10 +716,10 @@ stream<NextLayer, deflateSupported>::
 read(DynamicBuffer& buffer, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     std::size_t bytes_written = 0;
     do
     {
@@ -739,10 +739,10 @@ stream<NextLayer, deflateSupported>::
 async_read(DynamicBuffer& buffer, ReadHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     read_op<DynamicBuffer, BOOST_ASIO_HANDLER_TYPE(
@@ -763,10 +763,10 @@ read_some(
     std::size_t limit)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     error_code ec;
     auto const bytes_written =
         read_some(buffer, limit, ec);
@@ -785,10 +785,10 @@ read_some(
     error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     using beast::detail::clamp;
     if(! limit)
         limit = (std::numeric_limits<std::size_t>::max)();
@@ -815,10 +815,10 @@ async_read_some(
     ReadHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     read_op<DynamicBuffer, BOOST_ASIO_HANDLER_TYPE(
@@ -838,10 +838,10 @@ read_some(
     MutableBufferSequence const& buffers)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     error_code ec;
     auto const bytes_written = read_some(buffers, ec);
     if(ec)
@@ -858,10 +858,10 @@ read_some(
     error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     using beast::detail::clamp;
     auto& impl = *impl_;
     close_code code{};
@@ -1196,10 +1196,10 @@ async_read_some(
     ReadHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
-        "MutableBufferSequence requirements not met");
+        "MutableBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         ReadHandler, void(error_code, std::size_t));
     read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
diff --git a/include/boost/beast/websocket/impl/stream.hpp b/include/boost/beast/websocket/impl/stream.hpp
index 49289049..66a8f455 100644
--- a/include/boost/beast/websocket/impl/stream.hpp
+++ b/include/boost/beast/websocket/impl/stream.hpp
@@ -132,7 +132,7 @@ read_size_hint(DynamicBuffer& buffer) const
 {
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer requirements not met");
+        "DynamicBuffer type requirements not met");
     auto const initial_size = (std::min)(
         +tcp_frame_size,
         buffer.max_size() - buffer.size());
diff --git a/include/boost/beast/websocket/impl/teardown.hpp b/include/boost/beast/websocket/impl/teardown.hpp
index 6bd643c0..c28b0e88 100644
--- a/include/boost/beast/websocket/impl/teardown.hpp
+++ b/include/boost/beast/websocket/impl/teardown.hpp
@@ -181,7 +181,7 @@ async_teardown(
 {
     static_assert(beast::detail::is_invocable<
         TeardownHandler, void(error_code)>::value,
-            "TeardownHandler requirements not met");
+            "TeardownHandler type requirements not met");
     detail::teardown_tcp_op<
         Protocol,
         Executor,
diff --git a/include/boost/beast/websocket/impl/write.hpp b/include/boost/beast/websocket/impl/write.hpp
index cc6ab913..19a65258 100644
--- a/include/boost/beast/websocket/impl/write.hpp
+++ b/include/boost/beast/websocket/impl/write.hpp
@@ -439,10 +439,10 @@ stream<NextLayer, deflateSupported>::
 write_some(bool fin, ConstBufferSequence const& buffers)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     error_code ec;
     auto const bytes_transferred =
         write_some(fin, buffers, ec);
@@ -459,10 +459,10 @@ write_some(bool fin,
     ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     using beast::detail::clamp;
     auto& impl = *impl_;
     std::size_t bytes_transferred = 0;
@@ -672,10 +672,10 @@ async_write_some(bool fin,
     ConstBufferSequence const& bs, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
     write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
@@ -693,10 +693,10 @@ stream<NextLayer, deflateSupported>::
 write(ConstBufferSequence const& buffers)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     error_code ec;
     auto const bytes_transferred = write(buffers, ec);
     if(ec)
@@ -711,10 +711,10 @@ stream<NextLayer, deflateSupported>::
 write(ConstBufferSequence const& buffers, error_code& ec)
 {
     static_assert(is_sync_stream<next_layer_type>::value,
-        "SyncStream requirements not met");
+        "SyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     return write_some(true, buffers, ec);
 }
 
@@ -727,10 +727,10 @@ async_write(
     ConstBufferSequence const& bs, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
-        "AsyncStream requirements not met");
+        "AsyncStream type requirements not met");
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     BOOST_BEAST_HANDLER_INIT(
         WriteHandler, void(error_code, std::size_t));
     write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
diff --git a/test/beast/core/buffer_traits.cpp b/test/beast/core/buffer_traits.cpp
index 20a5c143..1fab7bde 100644
--- a/test/beast/core/buffer_traits.cpp
+++ b/test/beast/core/buffer_traits.cpp
@@ -146,7 +146,7 @@ public:
     {
         static_assert(
             net::is_const_buffer_sequence<BufferSequence>::value,
-            "BufferSequence requirements not met");
+            "BufferSequence type requirements not met");
         auto const first = net::buffer_sequence_begin (buffers);
         if (first == net::buffer_sequence_end (buffers))
             return {};
diff --git a/test/beast/core/stream_traits.cpp b/test/beast/core/stream_traits.cpp
index 39f0dcaa..33cffbc5 100644
--- a/test/beast/core/stream_traits.cpp
+++ b/test/beast/core/stream_traits.cpp
@@ -124,7 +124,7 @@ public:
 
     public:
         static_assert(is_sync_write_stream<NextLayer>::value,
-            "SyncWriteStream requirements not met");
+            "SyncWriteStream type requirements not met");
 
         template<class... Args>
         explicit
diff --git a/test/bench/parser/nodejs_parser.hpp b/test/bench/parser/nodejs_parser.hpp
index 98904293..bc7703c3 100644
--- a/test/bench/parser/nodejs_parser.hpp
+++ b/test/bench/parser/nodejs_parser.hpp
@@ -266,7 +266,7 @@ nodejs_basic_parser<Derived>::write(
 {
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
-            "ConstBufferSequence requirements not met");
+            "ConstBufferSequence type requirements not met");
     std::size_t bytes_used = 0;
     for(auto buffer : beast::buffers_range_ref(buffers))
     {
diff --git a/test/doc/core_1_refresher.cpp b/test/doc/core_1_refresher.cpp
index 619f3bdc..90bffc98 100644
--- a/test/doc/core_1_refresher.cpp
+++ b/test/doc/core_1_refresher.cpp
@@ -91,7 +91,7 @@ std::string string_from_buffers (ConstBufferSequence const& buffers)
     // check that the type meets the requirements using the provided type traits
     static_assert(
         net::is_const_buffer_sequence<ConstBufferSequence>::value,
-        "ConstBufferSequence requirements not met");
+        "ConstBufferSequence type requirements not met");
 
     // optimization: reserve all the space for the string first
     std::string result;
diff --git a/test/doc/core_snippets.cpp b/test/doc/core_snippets.cpp
index 131a73af..d36683b2 100644
--- a/test/doc/core_snippets.cpp
+++ b/test/doc/core_snippets.cpp
@@ -75,7 +75,7 @@ template<class SyncWriteStream>
 void write_string(SyncWriteStream& stream, string_view s)
 {
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     net::write(stream, net::const_buffer(s.data(), s.size()));
 }
 
diff --git a/test/doc/exemplars.cpp b/test/doc/exemplars.cpp
index dd72437d..3f233628 100644
--- a/test/doc/exemplars.cpp
+++ b/test/doc/exemplars.cpp
@@ -269,7 +269,7 @@ protected:
 };
 
 static_assert(is_fields<Fields>::value,
-    "Fields requirements not met");
+    "Fields type requirements not met");
 
 //]
 
diff --git a/test/doc/http_snippets.cpp b/test/doc/http_snippets.cpp
index 1a4f83c5..3784bd2c 100644
--- a/test/doc/http_snippets.cpp
+++ b/test/doc/http_snippets.cpp
@@ -311,9 +311,9 @@ send(
 {
     // Check the template types
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
-        "SyncWriteStream requirements not met");
+        "SyncWriteStream type requirements not met");
     static_assert(is_body_writer<Body>::value,
-        "BodyWriter requirements not met");
+        "BodyWriter type requirements not met");
 
     // Create the instance of serializer for the message
     serializer<isRequest, Body, Fields> sr{m};
@@ -337,7 +337,7 @@ void
 print_response(SyncReadStream& stream)
 {
     static_assert(is_sync_read_stream<SyncReadStream>::value,
-        "SyncReadStream requirements not met");
+        "SyncReadStream type requirements not met");
 
     // Declare a parser for an HTTP response
     response_parser<string_body> parser;