update boost on linux

linx64/include/boost/hana/fwd/string.hpp

@@ -12,6 +12,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/config.hpp>
 #include <boost/hana/fwd/core/make.hpp>
+#include <boost/hana/fwd/core/to.hpp>
 
 
 BOOST_HANA_NAMESPACE_BEGIN
@@ -39,7 +40,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! In particular, one should not take for granted that the template
     //! parameters are `char`s. The proper way to access the contents of
     //! a `hana::string` as character constants is to use `hana::unpack`,
-    //! `.c_str()` or `hana::to<char const*>`, as documented below.
+    //! `.c_str()` or `hana::to<char const*>`, as documented below. More
+    //! details [in the tutorial](@ref tutorial-containers-types).
     //!
     //!
     //! Modeled concepts
@@ -94,16 +96,23 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! concepts as `hana::string` does.
     //! @include example/string/to.cpp
     //!
+    //! Conversion from any Constant holding a `char const*`
+    //! ----------------------------------------------------
+    //! A `hana::string` can be created from any `Constant` whose underlying
+    //! value is convertible to a `char const*` by using `hana::to`. The
+    //! contents of the `char const*` are used to build the content of the
+    //! `hana::string`.
+    //! @include example/string/from_c_str.cpp
     //!
-    //! > #### Rationale for `hana::string` not being a `Constant`
-    //! > The underlying type held by a `hana::string` could be either
-    //! > `char const*` or some other constexpr-enabled string-like container.
-    //! > In the first case, `hana::string` can not be a `Constant` because
-    //! > the models of several concepts would not be respected by the
-    //! > underlying type, causing `value` not to be structure-preserving.
-    //! > Providing an underlying value of constexpr-enabled string-like
-    //! > container type like `std::string_view` would be great, but that's
-    //! > a bit complicated for the time being.
+    //! Rationale for `hana::string` not being a `Constant` itself
+    //! ----------------------------------------------------------
+    //! The underlying type held by a `hana::string` could be either `char const*`
+    //! or some other constexpr-enabled string-like container. In the first case,
+    //! `hana::string` can not be a `Constant` because the models of several
+    //! concepts would not be respected by the underlying type, causing `value`
+    //! not to be structure-preserving. Providing an underlying value of
+    //! constexpr-enabled string-like container type like `std::string_view`
+    //! would be great, but that's a bit complicated for the time being.
     template <typename implementation_defined>
     struct string {
         // Default-construct a `hana::string`; no-op since `hana::string` is stateless.
@@ -180,6 +189,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @relates hana::string
     constexpr auto make_string = make<string_tag>;
 
+    //! Equivalent to `to<string_tag>`; provided for convenience.
+    //! @relates hana::string
+    constexpr auto to_string = to<string_tag>;
+
     //! Create a compile-time string from a parameter pack of characters.
     //! @relates hana::string
     //!
@@ -200,7 +213,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     //!
     //! This macro is a more convenient alternative to `string_c` for creating
     //! compile-time strings. However, since this macro uses a lambda
-    //! internally, it can't be used in an unevaluated context.
+    //! internally, it can't be used in an unevaluated context, or where
+    //! a constant expression is expected before C++17.
     //!
     //!
     //! Example