diff --git a/doc/tutorial.hpp b/doc/tutorial.hpp
index 0b546390e4..c5e99b41ee 100644
--- a/doc/tutorial.hpp
+++ b/doc/tutorial.hpp
@@ -1703,7 +1703,7 @@ that type and cast it to `void`, for the same reason as we did for non-static
 members.
 
 
-@subsubsection tutorial-introspection-is_valid-typename Nested type names
+@subsubsection tutorial-introspection-is_valid-nested-typename Nested type names
 
 Checking for a nested type name is not hard, but it is slightly more
 convoluted than the previous cases:
@@ -1716,7 +1716,7 @@ support types that can't be returned from functions, like array types or
 incomplete types.
 
 
-@subsubsection tutorial-introspection-is_valid-template Nested templates
+@subsubsection tutorial-introspection-is_valid-nested-template Nested templates
 
 Checking for a nested template name is similar to checking for a nested type
 name, except we use the `template_<...>` variable template instead of
@@ -1725,6 +1725,21 @@ name, except we use the `template_<...>` variable template instead of
 @snippet example/tutorial/introspection.cpp nested_template
 
 
+@subsubsection tutorial-introspection-is_valid-template Template specializations
+
+Checking whether a template specialization is valid can be done too, but we
+now pass a `template_<...>` to `is_valid` instead of a `type<...>`, because
+that's what we want to make the check on:
+
+@snippet example/tutorial/introspection.cpp template_specialization
+
+@note
+Doing this will not cause the template to be instantiated. Hence, it will only
+check whether the given template can be mentioned with the provided template
+arguments, not whether the instantiation of the template with those arguments
+is valid. Generally speaking, there is no way to check that programmatically.
+
+
 @subsection tutorial-introspection-sfinae Taking control of SFINAE
 
 Doing something only if an expression is well-formed is a very common pattern
@@ -2024,7 +2039,10 @@ a container unspecified; they are explained in the
 [rationales](@ref tutorial-rationales-container_representation).
 When the representation of a container is implementation-defined, one must
 be careful not to make any assumptions about it, unless those assumption
-are explicitly allowed in the documentation of the container.
+are explicitly allowed in the documentation of the container. For example,
+assuming that one can safely inherit from a container or that the elements
+in the container are stored in the same order as specified in its template
+argument list is generally not safe.
 
 
 @subsubsection tutorial-containers-types-overloading Overloading on container types
@@ -2817,9 +2835,12 @@ very useful for porting existing code from e.g. Fusion/MPL to Hana:
 @snippet example/tutorial/ext/fusion_to_hana.cpp main
 
 @note
-At this time, only adapters to use data types from other libraries inside Hana
-are provided; adapters for the other way around (using Hana containers inside
-other libraries) are not provided.
+- At this time, only adapters to use data types from other libraries inside Hana
+  are provided; adapters for the other way around (using Hana containers inside
+  other libraries) are not provided.
+
+- The Fusion and MPL adapters are only guaranteed to work on the version of
+  Boost matching the version of Hana being used.
 
 However, using external adapters has a couple of pitfalls. For example, after
 a while using Hana, you might become used to comparing Hana tuples using the
diff --git a/example/map/difference.cpp b/example/map/difference.cpp
index 86bce0bc49..6b94b0a224 100644
--- a/example/map/difference.cpp
+++ b/example/map/difference.cpp
@@ -10,24 +10,23 @@
 
 #include <string>
 namespace hana = boost::hana;
-using namespace hana::literals;
 
 
-constexpr auto m1 = hana::make_map(
-    hana::make_pair("key1"_s, hana::type_c<std::string>),
-    hana::make_pair("key2"_s, hana::type_c<std::string>)
+static auto m1 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key1"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key2"), hana::type_c<std::string>)
 );
 
-constexpr auto m2 = hana::make_map(
-    hana::make_pair("key3"_s, hana::type_c<std::string>),
-    hana::make_pair("key4"_s, hana::type_c<std::string>),
-    hana::make_pair("key5"_s, hana::type_c<std::string>)
+static auto m2 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key3"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key5"), hana::type_c<std::string>)
 );
 
-constexpr auto m3 = hana::make_map(
-    hana::make_pair("key1"_s, hana::type_c<std::string>),
-    hana::make_pair("key4"_s, hana::type_c<int>),
-    hana::make_pair("key2"_s, hana::type_c<long long>)
+static auto m3 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key1"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<int>),
+    hana::make_pair(BOOST_HANA_STRING("key2"), hana::type_c<long long>)
 );
 
 int main() {
@@ -36,11 +35,11 @@ int main() {
     BOOST_HANA_CONSTANT_CHECK(hana::difference(m1, m3) == hana::make_map());
 
     BOOST_HANA_CONSTANT_CHECK(hana::difference(m3, m1) == hana::make_map(
-        hana::make_pair("key4"_s, hana::type_c<int>)
+        hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<int>)
     ));
 
     BOOST_HANA_CONSTANT_CHECK(hana::difference(m2, m3) == hana::make_map(
-        hana::make_pair("key3"_s, hana::type_c<std::string>),
-        hana::make_pair("key5"_s, hana::type_c<std::string>)
+        hana::make_pair(BOOST_HANA_STRING("key3"), hana::type_c<std::string>),
+        hana::make_pair(BOOST_HANA_STRING("key5"), hana::type_c<std::string>)
     ));
 }
diff --git a/example/map/intersection.cpp b/example/map/intersection.cpp
index 1dbe336dd9..1be8bf0b9b 100644
--- a/example/map/intersection.cpp
+++ b/example/map/intersection.cpp
@@ -13,35 +13,35 @@ namespace hana = boost::hana;
 using namespace hana::literals;
 
 
-constexpr auto m1 = hana::make_map(
-    hana::make_pair("key1"_s, hana::type_c<std::string>),
-    hana::make_pair("key2"_s, hana::type_c<std::string>)
+static auto m1 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key1"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key2"), hana::type_c<std::string>)
 );
 
-constexpr auto m2 = hana::make_map(
-    hana::make_pair("key3"_s, hana::type_c<std::string>),
-    hana::make_pair("key4"_s, hana::type_c<std::string>),
-    hana::make_pair("key5"_s, hana::type_c<std::string>)
+static auto m2 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key3"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key5"), hana::type_c<std::string>)
 );
 
 BOOST_HANA_CONSTANT_CHECK(hana::intersection(m1, m2) == hana::make_map());
 
-constexpr auto m3 = hana::make_map(
+static auto m3 = hana::make_map(
     hana::make_pair(hana::type_c<int>, hana::int_c<1>),
     hana::make_pair(hana::type_c<bool>, hana::bool_c<true>),
-    hana::make_pair(hana::type_c<std::string>, "hana"_s),
+    hana::make_pair(hana::type_c<std::string>, BOOST_HANA_STRING("hana")),
     hana::make_pair(hana::type_c<float>, hana::int_c<100>)
 );
 
-constexpr auto m4 = hana::make_map(
+static auto m4 = hana::make_map(
        hana::make_pair(hana::type_c<char>, hana::char_c<'c'>),
        hana::make_pair(hana::type_c<bool>, hana::bool_c<false>),
-       hana::make_pair(hana::type_c<std::string>, "boost"_s)
+       hana::make_pair(hana::type_c<std::string>, BOOST_HANA_STRING("boost"))
 );
 
 BOOST_HANA_CONSTANT_CHECK(hana::intersection(m3, m4) == hana::make_map(
     hana::make_pair(hana::type_c<bool>, hana::bool_c<true>),
-    hana::make_pair(hana::type_c<std::string>, "hana"_s)
+    hana::make_pair(hana::type_c<std::string>, BOOST_HANA_STRING("hana"))
 ));
 
 int main() { }
diff --git a/example/map/union.cpp b/example/map/union.cpp
index 98afb1b480..d214b34df6 100644
--- a/example/map/union.cpp
+++ b/example/map/union.cpp
@@ -15,23 +15,23 @@ namespace hana = boost::hana;
 using namespace hana::literals;
 
 
-constexpr auto m1 = hana::make_map(
-    hana::make_pair("key1"_s, hana::type_c<std::string>),
-    hana::make_pair("key2"_s, hana::type_c<std::string>)
+static auto m1 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key1"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key2"), hana::type_c<std::string>)
 );
 
-constexpr auto m2 = hana::make_map(
-    hana::make_pair("key3"_s, hana::type_c<std::string>),
-    hana::make_pair("key4"_s, hana::type_c<std::string>),
-    hana::make_pair("key5"_s, hana::type_c<std::string>)
+static auto m2 = hana::make_map(
+    hana::make_pair(BOOST_HANA_STRING("key3"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<std::string>),
+    hana::make_pair(BOOST_HANA_STRING("key5"), hana::type_c<std::string>)
 );
 
 BOOST_HANA_CONSTANT_CHECK(hana::union_(m1, m2) == hana::make_map(
-       hana::make_pair("key1"_s, hana::type_c<std::string>),
-       hana::make_pair("key2"_s, hana::type_c<std::string>),
-       hana::make_pair("key3"_s, hana::type_c<std::string>),
-       hana::make_pair("key4"_s, hana::type_c<std::string>),
-       hana::make_pair("key5"_s, hana::type_c<std::string>)
+       hana::make_pair(BOOST_HANA_STRING("key1"), hana::type_c<std::string>),
+       hana::make_pair(BOOST_HANA_STRING("key2"), hana::type_c<std::string>),
+       hana::make_pair(BOOST_HANA_STRING("key3"), hana::type_c<std::string>),
+       hana::make_pair(BOOST_HANA_STRING("key4"), hana::type_c<std::string>),
+       hana::make_pair(BOOST_HANA_STRING("key5"), hana::type_c<std::string>)
 ));
 
 constexpr auto m3 = hana::make_map(
diff --git a/example/transform.cpp b/example/transform.cpp
index fd330ba368..0bdf4cb09d 100644
--- a/example/transform.cpp
+++ b/example/transform.cpp
@@ -33,7 +33,7 @@ int main() {
     BOOST_HANA_RUNTIME_CHECK(hana::transform(hana::just(123), to_string) == hana::just("123"s));
 
     BOOST_HANA_CONSTANT_CHECK(
-        hana::transform(hana::tuple_t<void, int(), char[10]>, hana::template_<std::add_pointer_t>)
+        hana::transform(hana::tuple_t<void, int(), char[10]>, hana::metafunction<std::add_pointer>)
                 ==
         hana::tuple_t<void*, int(*)(), char(*)[10]>
     );
diff --git a/example/tuple/tuple_c.cpp b/example/tuple/tuple_c.cpp
index 8da09554cb..012221745b 100644
--- a/example/tuple/tuple_c.cpp
+++ b/example/tuple/tuple_c.cpp
@@ -13,7 +13,7 @@ namespace hana = boost::hana;
 
 int main() {
     BOOST_HANA_CONSTANT_CHECK(
-        hana::to_tuple(hana::tuple_c<int, 0, 1, 2>)
+        hana::tuple_c<int, 0, 1, 2>
             ==
         hana::make_tuple(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>)
     );
diff --git a/example/tutorial/introspection.cpp b/example/tutorial/introspection.cpp
index 4b53ecc934..3b72db447c 100644
--- a/example/tutorial/introspection.cpp
+++ b/example/tutorial/introspection.cpp
@@ -139,3 +139,20 @@ BOOST_HANA_CONSTANT_CHECK(has_member(hana::type_c<Foo>));
 BOOST_HANA_CONSTANT_CHECK(!has_member(hana::type_c<Bar>));
 //! [nested_template]
 }
+
+namespace template_specialization {
+//! [template_specialization]
+template <typename T, typename U>
+struct Foo;
+
+template <typename T>
+struct Bar;
+
+auto is_binary_template = hana::is_valid([](auto trait) -> decltype(
+  trait(hana::type_c<void>, hana::type_c<void>)
+) { });
+
+BOOST_HANA_CONSTANT_CHECK(is_binary_template(hana::template_<Foo>));
+BOOST_HANA_CONSTANT_CHECK(!is_binary_template(hana::template_<Bar>));
+//! [template_specialization]
+}
diff --git a/include/boost/hana/empty.hpp b/include/boost/hana/empty.hpp
index 8cb97a3ebc..86b81f408c 100644
--- a/include/boost/hana/empty.hpp
+++ b/include/boost/hana/empty.hpp
@@ -20,21 +20,21 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct empty_t {
+    constexpr auto empty_t<M>::operator()() const {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::MonadPlus<M>::value,
         "hana::empty<M>() requires 'M' to be a MonadPlus");
     #endif
 
-        constexpr auto operator()() const {
-            using Empty = BOOST_HANA_DISPATCH_IF(empty_impl<M>,
-                hana::MonadPlus<M>::value
-            );
+        using Empty = BOOST_HANA_DISPATCH_IF(empty_impl<M>,
+            hana::MonadPlus<M>::value
+        );
 
-            return Empty::apply();
-        }
-    };
+        return Empty::apply();
+    }
+    //! @endcond
 
     template <typename M, bool condition>
     struct empty_impl<M, when<condition>> : default_ {
diff --git a/include/boost/hana/experimental/printable.hpp b/include/boost/hana/experimental/printable.hpp
index e24a3426ea..f41d3fd906 100644
--- a/include/boost/hana/experimental/printable.hpp
+++ b/include/boost/hana/experimental/printable.hpp
@@ -99,7 +99,7 @@ BOOST_HANA_NAMESPACE_BEGIN namespace experimental {
 
     namespace print_detail {
         std::string strip_type_junk(std::string const& str) {
-            return std::regex_replace(str, std::regex("^([a-z_]+::)*([a-z_]*)_t<"), "$2<");
+            return std::regex_replace(str, std::regex("(?:struct )?([a-z_]+::)*([a-z_]*)_t<((?:struct )?[a-z:<>_]*)>"), "$2<$3>");
         }
     }
 
diff --git a/include/boost/hana/ext/boost/mpl/vector.hpp b/include/boost/hana/ext/boost/mpl/vector.hpp
index 29e9972b5d..706c2dd06d 100644
--- a/include/boost/hana/ext/boost/mpl/vector.hpp
+++ b/include/boost/hana/ext/boost/mpl/vector.hpp
@@ -99,9 +99,25 @@ BOOST_HANA_NAMESPACE_BEGIN
         using vector_tag = ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type;
     }}}
 
+    namespace mpl_detail {
+        // When `BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES` is not defined (e.g. on
+        // MSVC), different MPL sequences (like vector0 and vector1) have different
+        // tags, so we need to take that into account when we compare them.
+#ifndef BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
+        template <typename T1, typename T2>
+        struct is_same_mpl_vector_tag : std::false_type { };
+
+        template <template <long> class Tag, long x, long y>
+        struct is_same_mpl_vector_tag<Tag<x>, Tag<y>> : std::true_type { };
+#else
+        template <typename T1, typename T2>
+        struct is_same_mpl_vector_tag : std::is_same<T1, T2> { };
+#endif
+    }
+
     template <typename T>
     struct tag_of<T, when<
-        std::is_same<
+        mpl_detail::is_same_mpl_vector_tag<
             typename ::boost::mpl::sequence_tag<T>::type,
             ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type
         >::value
diff --git a/include/boost/hana/fwd/basic_tuple.hpp b/include/boost/hana/fwd/basic_tuple.hpp
index 8444f0f50e..69d4073f03 100644
--- a/include/boost/hana/fwd/basic_tuple.hpp
+++ b/include/boost/hana/fwd/basic_tuple.hpp
@@ -22,6 +22,11 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! `std::tuple`, `basic_tuple` provides the strict minimum required to
     //! implement a closure with maximum compile-time efficiency.
     //!
+    //! @note
+    //! When you use a container, remember not to make assumptions about its
+    //! representation, unless the documentation gives you those guarantees.
+    //! More details [in the tutorial](@ref tutorial-containers-types).
+    //!
     //!
     //! Modeled concepts
     //! ----------------
diff --git a/include/boost/hana/fwd/empty.hpp b/include/boost/hana/fwd/empty.hpp
index ed3cc38cc7..719f58055f 100644
--- a/include/boost/hana/fwd/empty.hpp
+++ b/include/boost/hana/fwd/empty.hpp
@@ -41,7 +41,9 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct empty_impl : empty_impl<M, when<true>> { };
 
     template <typename M>
-    struct empty_t;
+    struct empty_t {
+        constexpr auto operator()() const;
+    };
 
     template <typename M>
     constexpr empty_t<M> empty{};
diff --git a/include/boost/hana/fwd/lift.hpp b/include/boost/hana/fwd/lift.hpp
index 9491dab8a4..2d4ac6cc13 100644
--- a/include/boost/hana/fwd/lift.hpp
+++ b/include/boost/hana/fwd/lift.hpp
@@ -49,7 +49,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct lift_impl : lift_impl<A, when<true>> { };
 
     template <typename A>
-    struct lift_t;
+    struct lift_t {
+        template <typename X>
+        constexpr auto operator()(X&& x) const;
+    };
 
     template <typename A>
     constexpr lift_t<A> lift{};
diff --git a/include/boost/hana/fwd/map.hpp b/include/boost/hana/fwd/map.hpp
index c00f57195f..782b0f1e97 100644
--- a/include/boost/hana/fwd/map.hpp
+++ b/include/boost/hana/fwd/map.hpp
@@ -36,21 +36,23 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! keys must be `Hashable`, and any two keys with equal hashes must be
     //! `Comparable` with each other at compile-time.
     //!
-    //! Note that the actual representation of a `hana::map` is an implementation
+    //! @note
+    //! The actual representation of a `hana::map` is an implementation
     //! detail. As such, one should not assume anything more than what is
     //! explicitly documented as being part of the interface of a map,
     //! such as:
     //! - the presence of additional constructors
     //! - the presence of additional assignment operators
     //! - the fact that `hana::map<Pairs...>` is, or is not, a dependent type
-    //!
+    //! .
     //! In particular, the last point is very important; `hana::map<Pairs...>`
     //! is basically equivalent to
     //! @code
     //!     decltype(hana::make_pair(std::declval<Pairs>()...))
     //! @endcode
     //! which is not something that can be pattern-matched on during template
-    //! argument deduction, for example.
+    //! argument deduction, for example. More details [in the tutorial]
+    //! (@ref tutorial-containers-types).
     //!
     //!
     //! Modeled concepts
diff --git a/include/boost/hana/fwd/monadic_fold_left.hpp b/include/boost/hana/fwd/monadic_fold_left.hpp
index c037989dea..aa66097b3e 100644
--- a/include/boost/hana/fwd/monadic_fold_left.hpp
+++ b/include/boost/hana/fwd/monadic_fold_left.hpp
@@ -94,7 +94,13 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct monadic_fold_left_impl : monadic_fold_left_impl<T, when<true>> { };
 
     template <typename M>
-    struct monadic_fold_left_t;
+    struct monadic_fold_left_t {
+        template <typename Xs, typename State, typename F>
+        constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const;
+
+        template <typename Xs, typename F>
+        constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
+    };
 
     template <typename M>
     constexpr monadic_fold_left_t<M> monadic_fold_left{};
diff --git a/include/boost/hana/fwd/monadic_fold_right.hpp b/include/boost/hana/fwd/monadic_fold_right.hpp
index 2028e15369..fff6fc0c1f 100644
--- a/include/boost/hana/fwd/monadic_fold_right.hpp
+++ b/include/boost/hana/fwd/monadic_fold_right.hpp
@@ -96,7 +96,13 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct monadic_fold_right_impl : monadic_fold_right_impl<T, when<true>> { };
 
     template <typename M>
-    struct monadic_fold_right_t;
+    struct monadic_fold_right_t {
+        template <typename Xs, typename State, typename F>
+        constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const;
+
+        template <typename Xs, typename F>
+        constexpr decltype(auto) operator()(Xs&& xs, F&& f) const;
+    };
 
     template <typename M>
     constexpr monadic_fold_right_t<M> monadic_fold_right{};
diff --git a/include/boost/hana/fwd/one.hpp b/include/boost/hana/fwd/one.hpp
index d2c67b7228..27d4f37bd6 100644
--- a/include/boost/hana/fwd/one.hpp
+++ b/include/boost/hana/fwd/one.hpp
@@ -35,7 +35,9 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct one_impl : one_impl<R, when<true>> { };
 
     template <typename R>
-    struct one_t;
+    struct one_t {
+        constexpr decltype(auto) operator()() const;
+    };
 
     template <typename R>
     constexpr one_t<R> one{};
diff --git a/include/boost/hana/fwd/optional.hpp b/include/boost/hana/fwd/optional.hpp
index 28bb68e8af..8a348a8b12 100644
--- a/include/boost/hana/fwd/optional.hpp
+++ b/include/boost/hana/fwd/optional.hpp
@@ -38,6 +38,11 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! by the compiler. This makes `hana::optional` well suited for static
     //! metaprogramming tasks, but very poor for anything dynamic.
     //!
+    //! @note
+    //! When you use a container, remember not to make assumptions about its
+    //! representation, unless the documentation gives you those guarantees.
+    //! More details [in the tutorial](@ref tutorial-containers-types).
+    //!
     //!
     //! Interoperation with `type`s
     //! ---------------------------
diff --git a/include/boost/hana/fwd/pair.hpp b/include/boost/hana/fwd/pair.hpp
index 897e87ad12..1ce0e22772 100644
--- a/include/boost/hana/fwd/pair.hpp
+++ b/include/boost/hana/fwd/pair.hpp
@@ -24,6 +24,11 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! Instead, one must use the `hana::first` and `hana::second` free
     //! functions to access the elements of a pair.
     //!
+    //! @note
+    //! When you use a container, remember not to make assumptions about its
+    //! representation, unless the documentation gives you those guarantees.
+    //! More details [in the tutorial](@ref tutorial-containers-types).
+    //!
     //!
     //! Modeled concepts
     //! ----------------
diff --git a/include/boost/hana/fwd/product.hpp b/include/boost/hana/fwd/product.hpp
index 96bbd77c4e..ff545ceacb 100644
--- a/include/boost/hana/fwd/product.hpp
+++ b/include/boost/hana/fwd/product.hpp
@@ -60,7 +60,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct product_impl : product_impl<T, when<true>> { };
 
     template <typename R>
-    struct product_t;
+    struct product_t {
+        template <typename Xs>
+        constexpr decltype(auto) operator()(Xs&& xs) const;
+    };
 
     template <typename R = integral_constant_tag<int>>
     constexpr product_t<R> product{};
diff --git a/include/boost/hana/fwd/range.hpp b/include/boost/hana/fwd/range.hpp
index 82d0f75232..3fb2a939dc 100644
--- a/include/boost/hana/fwd/range.hpp
+++ b/include/boost/hana/fwd/range.hpp
@@ -35,7 +35,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! The representation of `hana::range` is implementation defined. In
     //! particular, one should not take for granted the number and types
     //! of template parameters. The proper way to create a `hana::range`
-    //! is to use `hana::range_c` or `hana::make_range`.
+    //! is to use `hana::range_c` or `hana::make_range`. More details
+    //! [in the tutorial](@ref tutorial-containers-types).
     //!
     //!
     //! Modeled concepts
diff --git a/include/boost/hana/fwd/replicate.hpp b/include/boost/hana/fwd/replicate.hpp
index 4861adabae..842812d692 100644
--- a/include/boost/hana/fwd/replicate.hpp
+++ b/include/boost/hana/fwd/replicate.hpp
@@ -65,7 +65,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct replicate_impl : replicate_impl<M, when<true>> { };
 
     template <typename M>
-    struct replicate_t;
+    struct replicate_t {
+        template <typename X, typename N>
+        constexpr auto operator()(X&& x, N const& n) const;
+    };
 
     template <typename M>
     constexpr replicate_t<M> replicate{};
diff --git a/include/boost/hana/fwd/set.hpp b/include/boost/hana/fwd/set.hpp
index 7312854782..acbcbc7fb5 100644
--- a/include/boost/hana/fwd/set.hpp
+++ b/include/boost/hana/fwd/set.hpp
@@ -30,7 +30,8 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! In particular, one should not take for granted the order of the
     //! template parameters and the presence of any additional constructors
     //! or assignment operators than what is documented. The canonical way of
-    //! creating a `hana::set` is through `hana::make_set`.
+    //! creating a `hana::set` is through `hana::make_set`. More details
+    //! [in the tutorial](@ref tutorial-containers-types).
     //!
     //!
     //! Modeled concepts
diff --git a/include/boost/hana/fwd/string.hpp b/include/boost/hana/fwd/string.hpp
index 80c1622500..8af2e709ba 100644
--- a/include/boost/hana/fwd/string.hpp
+++ b/include/boost/hana/fwd/string.hpp
@@ -40,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
@@ -212,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
diff --git a/include/boost/hana/fwd/sum.hpp b/include/boost/hana/fwd/sum.hpp
index c565ecd7f7..6d7ee537b3 100644
--- a/include/boost/hana/fwd/sum.hpp
+++ b/include/boost/hana/fwd/sum.hpp
@@ -69,7 +69,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct sum_impl : sum_impl<T, when<true>> { };
 
     template <typename M>
-    struct sum_t;
+    struct sum_t {
+        template <typename Xs>
+        constexpr decltype(auto) operator()(Xs&& xs) const;
+    };
 
     template <typename M = integral_constant_tag<int>>
     constexpr sum_t<M> sum{};
diff --git a/include/boost/hana/fwd/tap.hpp b/include/boost/hana/fwd/tap.hpp
index 846c1d00e6..2f3809c1f3 100644
--- a/include/boost/hana/fwd/tap.hpp
+++ b/include/boost/hana/fwd/tap.hpp
@@ -55,7 +55,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct tap_impl : tap_impl<M, when<true>> { };
 
     template <typename M>
-    struct tap_t;
+    struct tap_t {
+        template <typename F>
+        constexpr auto operator()(F&& f) const;
+    };
 
     template <typename M>
     constexpr tap_t<M> tap{};
diff --git a/include/boost/hana/fwd/tuple.hpp b/include/boost/hana/fwd/tuple.hpp
index f51ab9ac22..9ee2e00ace 100644
--- a/include/boost/hana/fwd/tuple.hpp
+++ b/include/boost/hana/fwd/tuple.hpp
@@ -32,6 +32,11 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! sequence with a key-based access, then you should consider
     //! `hana::map` or `hana::set` instead.
     //!
+    //! @note
+    //! When you use a container, remember not to make assumptions about its
+    //! representation, unless the documentation gives you those guarantees.
+    //! More details [in the tutorial](@ref tutorial-containers-types).
+    //!
     //!
     //! Modeled concepts
     //! ----------------
diff --git a/include/boost/hana/fwd/type.hpp b/include/boost/hana/fwd/type.hpp
index c3c220db78..d087cee166 100644
--- a/include/boost/hana/fwd/type.hpp
+++ b/include/boost/hana/fwd/type.hpp
@@ -394,15 +394,13 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @endcode
     //!
     //! @note
-    //! `template_` can't be SFINAE-friendly right now because of
-    //! [Core issue 1430][1].
+    //! In a SFINAE context, the expression `template_<f>(type_c<x>...)` is
+    //! valid whenever the expression `f<x...>` is valid.
     //!
     //!
     //! Example
     //! -------
     //! @include example/type/template.cpp
-    //!
-    //! [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
     template <template <typename ...> class F>
     constexpr auto template_ = [](basic_type<T>...) {
@@ -426,6 +424,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     //!     decltype(metafunction<f>)::apply<x...>::type == f<x...>::type
     //! @endcode
     //!
+    //! @note
+    //! In a SFINAE context, the expression `metafunction<f>(type_c<x>...)` is
+    //! valid whenever the expression `f<x...>::%type` is valid.
+    //!
     //!
     //! Example
     //! -------
@@ -453,6 +455,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     //!     decltype(metafunction_class<f>)::apply<x...>::type == f::apply<x...>::type
     //! @endcode
     //!
+    //! @note
+    //! In a SFINAE context, the expression `metafunction_class<f>(type_c<x>...)`
+    //! is valid whenever the expression `f::apply<x...>::%type` is valid.
+    //!
     //!
     //! Example
     //! -------
@@ -464,9 +470,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 #else
     template <typename F>
-    struct metafunction_class_t
-        : metafunction_t<F::template apply>
-    { };
+    struct metafunction_class_t;
 
     template <typename F>
     constexpr metafunction_class_t<F> metafunction_class{};
@@ -498,6 +502,9 @@ BOOST_HANA_NAMESPACE_BEGIN
     //!   boost/hana/ext/std/integral_constant.hpp header to ensure
     //!   Hana can interoperate with the result.
     //!
+    //! - In a SFINAE context, the expression `integral(f)(t...)` is valid
+    //!   whenever the expression `decltype(f(t...))::%type` is valid.
+    //!
     //!
     //! Example
     //! -------
diff --git a/include/boost/hana/fwd/zero.hpp b/include/boost/hana/fwd/zero.hpp
index 412614786d..fcbcfcc372 100644
--- a/include/boost/hana/fwd/zero.hpp
+++ b/include/boost/hana/fwd/zero.hpp
@@ -35,7 +35,9 @@ BOOST_HANA_NAMESPACE_BEGIN
     struct zero_impl : zero_impl<M, when<true>> { };
 
     template <typename M>
-    struct zero_t;
+    struct zero_t {
+        constexpr decltype(auto) operator()() const;
+    };
 
     template <typename M>
     constexpr zero_t<M> zero{};
diff --git a/include/boost/hana/lift.hpp b/include/boost/hana/lift.hpp
index b8ab3431c2..c1d7803788 100644
--- a/include/boost/hana/lift.hpp
+++ b/include/boost/hana/lift.hpp
@@ -20,22 +20,22 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename A>
-    struct lift_t {
+    template <typename X>
+    constexpr auto lift_t<A>::operator()(X&& x) const {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Applicative<A>::value,
         "hana::lift<A> requires 'A' to be an Applicative");
     #endif
 
-        template <typename X>
-        constexpr auto operator()(X&& x) const {
-            using Lift = BOOST_HANA_DISPATCH_IF(lift_impl<A>,
-                hana::Applicative<A>::value
-            );
+        using Lift = BOOST_HANA_DISPATCH_IF(lift_impl<A>,
+            hana::Applicative<A>::value
+        );
 
-            return Lift::apply(static_cast<X&&>(x));
-        }
-    };
+        return Lift::apply(static_cast<X&&>(x));
+    }
+    //! @endcond
 
     template <typename A, bool condition>
     struct lift_impl<A, when<condition>> : default_ {
diff --git a/include/boost/hana/map.hpp b/include/boost/hana/map.hpp
index 8da5012190..7356208bc6 100644
--- a/include/boost/hana/map.hpp
+++ b/include/boost/hana/map.hpp
@@ -124,7 +124,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         };
 
         template <typename HashTable, typename Storage>
-        struct map_impl
+        struct map_impl final
             : detail::searchable_operators<map_impl<HashTable, Storage>>
             , detail::operators::adl<map_impl<HashTable, Storage>>
         {
diff --git a/include/boost/hana/monadic_fold_left.hpp b/include/boost/hana/monadic_fold_left.hpp
index e06c405604..3a1e8142a7 100644
--- a/include/boost/hana/monadic_fold_left.hpp
+++ b/include/boost/hana/monadic_fold_left.hpp
@@ -27,46 +27,50 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct monadic_fold_left_t {
+    template <typename Xs, typename State, typename F>
+    constexpr decltype(auto) monadic_fold_left_t<M>::operator()(Xs&& xs, State&& state, F&& f) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
+            hana::Foldable<S>::value
+        );
+
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Monad<M>::value,
         "hana::monadic_fold_left<M> requires 'M' to be a Monad");
-    #endif
 
-        template <typename Xs, typename State, typename F>
-        constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
-                hana::Foldable<S>::value
-            );
+        static_assert(hana::Foldable<S>::value,
+        "hana::monadic_fold_left<M>(xs, state, f) requires 'xs' to be Foldable");
+    #endif
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::monadic_fold_left<M>(xs, state, f) requires 'xs' to be Foldable");
-        #endif
+        return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
+                                                  static_cast<State&&>(state),
+                                                  static_cast<F&&>(f));
+    }
+    //! @endcond
 
-            return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
-                                                      static_cast<State&&>(state),
-                                                      static_cast<F&&>(f));
-        }
+    //! @cond
+    template <typename M>
+    template <typename Xs, typename F>
+    constexpr decltype(auto) monadic_fold_left_t<M>::operator()(Xs&& xs, F&& f) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
+            hana::Foldable<S>::value
+        );
 
-        template <typename Xs, typename F>
-        constexpr decltype(auto) operator()(Xs&& xs, F&& f) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
-                hana::Foldable<S>::value
-            );
+    #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
+        static_assert(hana::Monad<M>::value,
+        "hana::monadic_fold_left<M> requires 'M' to be a Monad");
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be Foldable");
-        #endif
+        static_assert(hana::Foldable<S>::value,
+        "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be Foldable");
+    #endif
 
-            return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
-                                                      static_cast<F&&>(f));
-        }
-    };
+        return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
+                                                  static_cast<F&&>(f));
+    }
+    //! @endcond
 
     namespace detail {
         struct foldlM_helper {
diff --git a/include/boost/hana/monadic_fold_right.hpp b/include/boost/hana/monadic_fold_right.hpp
index 7026b058c3..c822d1d003 100644
--- a/include/boost/hana/monadic_fold_right.hpp
+++ b/include/boost/hana/monadic_fold_right.hpp
@@ -27,45 +27,49 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct monadic_fold_right_t {
+    template <typename Xs, typename State, typename F>
+    constexpr decltype(auto) monadic_fold_right_t<M>::operator()(Xs&& xs, State&& state, F&& f) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>,
+            hana::Foldable<S>::value
+        );
+
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Monad<M>::value,
         "hana::monadic_fold_right<M> requires 'M' to be a Monad");
-    #endif
 
-        template <typename Xs, typename State, typename F>
-        constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>,
-                hana::Foldable<S>::value
-            );
+        static_assert(hana::Foldable<S>::value,
+        "hana::monadic_fold_right<M>(xs, state, f) requires 'xs' to be Foldable");
+    #endif
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::monadic_fold_right<M>(xs, state, f) requires 'xs' to be Foldable");
-        #endif
+        return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs),
+                                                   static_cast<State&&>(state),
+                                                   static_cast<F&&>(f));
+    }
+    //! @endcond
 
-            return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs),
-                                                       static_cast<State&&>(state),
-                                                       static_cast<F&&>(f));
-        }
+    //! @cond
+    template <typename M>
+    template <typename Xs, typename F>
+    constexpr decltype(auto) monadic_fold_right_t<M>::operator()(Xs&& xs, F&& f) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>,
+            hana::Foldable<S>::value
+        );
 
-        template <typename Xs, typename F>
-        constexpr decltype(auto) operator()(Xs&& xs, F&& f) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>,
-                hana::Foldable<S>::value
-            );
+    #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
+        static_assert(hana::Monad<M>::value,
+        "hana::monadic_fold_right<M> requires 'M' to be a Monad");
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be Foldable");
-        #endif
-            return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs),
-                                                       static_cast<F&&>(f));
-        }
-    };
+        static_assert(hana::Foldable<S>::value,
+        "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be Foldable");
+    #endif
+        return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs),
+                                                   static_cast<F&&>(f));
+    }
+    //! @endcond
 
     namespace detail {
         struct foldrM_helper {
diff --git a/include/boost/hana/one.hpp b/include/boost/hana/one.hpp
index b8d759b8c0..df27b1e834 100644
--- a/include/boost/hana/one.hpp
+++ b/include/boost/hana/one.hpp
@@ -23,21 +23,21 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename R>
-    struct one_t {
+    constexpr decltype(auto) one_t<R>::operator()() const {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Ring<R>::value,
         "hana::one<R>() requires 'R' to be a Ring");
     #endif
 
-        constexpr decltype(auto) operator()() const {
-            using One = BOOST_HANA_DISPATCH_IF(one_impl<R>,
-                hana::Ring<R>::value
-            );
+        using One = BOOST_HANA_DISPATCH_IF(one_impl<R>,
+            hana::Ring<R>::value
+        );
 
-            return One::apply();
-        }
-    };
+        return One::apply();
+    }
+    //! @endcond
 
     template <typename R, bool condition>
     struct one_impl<R, when<condition>> : default_ {
diff --git a/include/boost/hana/product.hpp b/include/boost/hana/product.hpp
index 8d3bad9fc3..a419b15b40 100644
--- a/include/boost/hana/product.hpp
+++ b/include/boost/hana/product.hpp
@@ -23,28 +23,26 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename R>
-    struct product_t {
+    template <typename Xs>
+    constexpr decltype(auto) product_t<R>::operator()(Xs&& xs) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using Product = BOOST_HANA_DISPATCH_IF(product_impl<S>,
+            hana::Foldable<S>::value
+        );
+
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Ring<R>::value,
         "hana::product<R> requires 'R' to be a Ring");
-    #endif
-
-        template <typename Xs>
-        constexpr decltype(auto) operator()(Xs&& xs) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using Product = BOOST_HANA_DISPATCH_IF(product_impl<S>,
-                hana::Foldable<S>::value
-            );
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::product<R>(xs) requires 'xs' to be Foldable");
-        #endif
+        static_assert(hana::Foldable<S>::value,
+        "hana::product<R>(xs) requires 'xs' to be Foldable");
+    #endif
 
-            return Product::template apply<R>(static_cast<Xs&&>(xs));
-        }
-    };
+        return Product::template apply<R>(static_cast<Xs&&>(xs));
+    }
+    //! @endcond
 
     template <typename T, bool condition>
     struct product_impl<T, when<condition>> : default_ {
diff --git a/include/boost/hana/replicate.hpp b/include/boost/hana/replicate.hpp
index f04c4d8a44..3d82712d4f 100644
--- a/include/boost/hana/replicate.hpp
+++ b/include/boost/hana/replicate.hpp
@@ -25,28 +25,26 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct replicate_t {
+    template <typename X, typename N>
+    constexpr auto replicate_t<M>::operator()(X&& x, N const& n) const {
+        using Replicate = BOOST_HANA_DISPATCH_IF(replicate_impl<M>,
+            hana::MonadPlus<M>::value &&
+            hana::IntegralConstant<N>::value
+        );
+
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::MonadPlus<M>::value,
         "hana::replicate<M>(x, n) requires 'M' to be a MonadPlus");
-    #endif
-
-        template <typename X, typename N>
-        constexpr auto operator()(X&& x, N const& n) const {
-            using Replicate = BOOST_HANA_DISPATCH_IF(replicate_impl<M>,
-                hana::MonadPlus<M>::value &&
-                hana::IntegralConstant<N>::value
-            );
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::IntegralConstant<N>::value,
-            "hana::replicate<M>(x, n) requires 'n' to be an IntegralConstant");
-        #endif
+        static_assert(hana::IntegralConstant<N>::value,
+        "hana::replicate<M>(x, n) requires 'n' to be an IntegralConstant");
+    #endif
 
-            return Replicate::apply(static_cast<X&&>(x), n);
-        }
-    };
+        return Replicate::apply(static_cast<X&&>(x), n);
+    }
+    //! @endcond
 
     template <typename M, bool condition>
     struct replicate_impl<M, when<condition>> : default_ {
diff --git a/include/boost/hana/set.hpp b/include/boost/hana/set.hpp
index 58979ed47f..53b4e8ec74 100644
--- a/include/boost/hana/set.hpp
+++ b/include/boost/hana/set.hpp
@@ -56,7 +56,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     //! @cond
     template <typename ...Xs>
-    struct set
+    struct set final
         : detail::operators::adl<set<Xs...>>
         , detail::searchable_operators<set<Xs...>>
     {
diff --git a/include/boost/hana/sum.hpp b/include/boost/hana/sum.hpp
index 5c86dafdde..2b6f6b8219 100644
--- a/include/boost/hana/sum.hpp
+++ b/include/boost/hana/sum.hpp
@@ -23,28 +23,26 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct sum_t {
+    template <typename Xs>
+    constexpr decltype(auto) sum_t<M>::operator()(Xs&& xs) const {
+        using S = typename hana::tag_of<Xs>::type;
+        using Sum = BOOST_HANA_DISPATCH_IF(sum_impl<S>,
+            hana::Foldable<S>::value
+        );
+
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Monoid<M>::value,
         "hana::sum<M> requires 'M' to be a Monoid");
-    #endif
-
-        template <typename Xs>
-        constexpr decltype(auto) operator()(Xs&& xs) const {
-            using S = typename hana::tag_of<Xs>::type;
-            using Sum = BOOST_HANA_DISPATCH_IF(sum_impl<S>,
-                hana::Foldable<S>::value
-            );
 
-        #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
-            static_assert(hana::Foldable<S>::value,
-            "hana::sum<M>(xs) requires 'xs' to be Foldable");
-        #endif
+        static_assert(hana::Foldable<S>::value,
+        "hana::sum<M>(xs) requires 'xs' to be Foldable");
+    #endif
 
-            return Sum::template apply<M>(static_cast<Xs&&>(xs));
-        }
-    };
+        return Sum::template apply<M>(static_cast<Xs&&>(xs));
+    }
+    //! @endcond
 
     template <typename T, bool condition>
     struct sum_impl<T, when<condition>> : default_ {
diff --git a/include/boost/hana/tap.hpp b/include/boost/hana/tap.hpp
index 7d37318255..332f9ff83d 100644
--- a/include/boost/hana/tap.hpp
+++ b/include/boost/hana/tap.hpp
@@ -20,22 +20,22 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct tap_t {
+    template <typename F>
+    constexpr auto tap_t<M>::operator()(F&& f) const {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Monad<M>::value,
         "hana::tap<M> requires 'M' to be a Monad");
     #endif
 
-        template <typename F>
-        constexpr auto operator()(F&& f) const {
-            using Tap = BOOST_HANA_DISPATCH_IF(tap_impl<M>,
-                hana::Monad<M>::value
-            );
+        using Tap = BOOST_HANA_DISPATCH_IF(tap_impl<M>,
+            hana::Monad<M>::value
+        );
 
-            return Tap::apply(static_cast<F&&>(f));
-        }
-    };
+        return Tap::apply(static_cast<F&&>(f));
+    }
+    //! @endcond
 
     namespace detail {
         template <typename M>
diff --git a/include/boost/hana/tuple.hpp b/include/boost/hana/tuple.hpp
index 3354a84bee..ae3cba819d 100644
--- a/include/boost/hana/tuple.hpp
+++ b/include/boost/hana/tuple.hpp
@@ -75,7 +75,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     // tuple
     //////////////////////////////////////////////////////////////////////////
     template <>
-    struct tuple<>
+    struct tuple<> final
         : detail::operators::adl<tuple<>>
         , detail::iterable_operators<tuple<>>
     {
@@ -84,7 +84,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     };
 
     template <typename ...Xn>
-    struct tuple
+    struct tuple final
         : detail::operators::adl<tuple<Xn...>>
         , detail::iterable_operators<tuple<Xn...>>
     {
diff --git a/include/boost/hana/type.hpp b/include/boost/hana/type.hpp
index 80a498753f..b1d3e2a308 100644
--- a/include/boost/hana/type.hpp
+++ b/include/boost/hana/type.hpp
@@ -14,6 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/bool.hpp>
 #include <boost/hana/config.hpp>
+#include <boost/hana/core/when.hpp>
 #include <boost/hana/detail/operators/adl.hpp>
 #include <boost/hana/detail/operators/comparable.hpp>
 #include <boost/hana/fwd/concept/metafunction.hpp>
@@ -152,6 +153,24 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     // template_
     //////////////////////////////////////////////////////////////////////////
+    // Note: We have to use the very complicated trick below instead of just
+    // mentionning `F<T...>` in a SFINAE-able context because of CWG 1430
+    // (http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_active.html#1430).
+    namespace template_detail {
+        template <typename ...T> struct args;
+        template <typename ...> using always_void = void;
+
+        template <template <typename ...> class F, typename Args, typename = void>
+        struct specialization_is_valid
+            : std::false_type
+        { };
+
+        template <template <typename ...> class F, typename ...T>
+        struct specialization_is_valid<F, args<T...>, always_void<F<T...>>>
+            : std::true_type
+        { };
+    } // end namespace detail
+
     template <template <typename ...> class F>
     struct template_t {
         template <typename ...T>
@@ -159,7 +178,9 @@ BOOST_HANA_NAMESPACE_BEGIN
             using type = F<T...>;
         };
 
-        template <typename ...T>
+        template <typename ...T, typename = std::enable_if_t<
+            template_detail::specialization_is_valid<F, template_detail::args<typename T::type...>>::value
+        >>
         constexpr auto operator()(T const& ...) const
         { return hana::type<F<typename T::type...>>{}; }
     };
@@ -177,6 +198,23 @@ BOOST_HANA_NAMESPACE_BEGIN
         operator()(T const& ...) const { return {}; }
     };
 
+    //////////////////////////////////////////////////////////////////////////
+    // metafunction_class
+    //////////////////////////////////////////////////////////////////////////
+    namespace detail {
+        template <typename F, typename ...T>
+        struct always_first { using type = F; };
+    }
+    template <typename F>
+    struct metafunction_class_t {
+        template <typename ...T>
+        using apply = typename detail::always_first<F, T...>::type::template apply<T...>;
+
+        template <typename ...T>
+        constexpr hana::type<typename detail::always_first<F, T...>::type::template apply<typename T::type...>::type>
+        operator()(T const& ...) const { return {}; }
+    };
+
     //////////////////////////////////////////////////////////////////////////
     // Metafunction
     //////////////////////////////////////////////////////////////////////////
@@ -200,9 +238,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     template <typename F>
     struct integral_t {
-        template <typename ...T>
-        constexpr auto operator()(T const& ...) const {
-            using Result = typename F::template apply<typename T::type...>::type;
+        template <typename ...T, typename Result =
+            typename detail::always_first<F, T...>::type::template apply<typename T::type...>::type
+        >
+        constexpr Result operator()(T const& ...) const {
             return Result{};
         }
     };
diff --git a/include/boost/hana/version.hpp b/include/boost/hana/version.hpp
index 70ba6fd9a1..c3a5b3982d 100644
--- a/include/boost/hana/version.hpp
+++ b/include/boost/hana/version.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 //! @ingroup group-config
 //! Macro expanding to the minor version of the library, i.e. the `y` in `x.y.z`.
-#define BOOST_HANA_MINOR_VERSION 4
+#define BOOST_HANA_MINOR_VERSION 5
 
 //! @ingroup group-config
 //! Macro expanding to the patch level of the library, i.e. the `z` in `x.y.z`.
diff --git a/include/boost/hana/zero.hpp b/include/boost/hana/zero.hpp
index baba9691f6..317023a1b3 100644
--- a/include/boost/hana/zero.hpp
+++ b/include/boost/hana/zero.hpp
@@ -23,21 +23,21 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 BOOST_HANA_NAMESPACE_BEGIN
+    //! @cond
     template <typename M>
-    struct zero_t {
+    constexpr decltype(auto) zero_t<M>::operator()() const {
     #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
         static_assert(hana::Monoid<M>::value,
         "hana::zero<M>() requires 'M' to be a Monoid");
     #endif
 
-        constexpr decltype(auto) operator()() const {
-            using Zero = BOOST_HANA_DISPATCH_IF(zero_impl<M>,
-                hana::Monoid<M>::value
-            );
+        using Zero = BOOST_HANA_DISPATCH_IF(zero_impl<M>,
+            hana::Monoid<M>::value
+        );
 
-            return Zero::apply();
-        }
-    };
+        return Zero::apply();
+    }
+    //! @endcond
 
     template <typename M, bool condition>
     struct zero_impl<M, when<condition>> : default_ {
diff --git a/test/experimental/printable/metafunction.cpp b/test/experimental/printable/metafunction.cpp
index 410d4d6753..5cfdb6a625 100644
--- a/test/experimental/printable/metafunction.cpp
+++ b/test/experimental/printable/metafunction.cpp
@@ -7,6 +7,7 @@
 #include <boost/hana/integral_constant.hpp>
 #include <boost/hana/type.hpp>
 
+#include <regex>
 #include <sstream>
 namespace hana = boost::hana;
 
@@ -22,20 +23,23 @@ int main() {
         ss << hana::experimental::print(
             hana::template_<foo::my_template>
         );
-        BOOST_HANA_RUNTIME_CHECK(ss.str() == "template<foo::my_template>");
+        BOOST_HANA_RUNTIME_CHECK(std::regex_match(ss.str(),
+            std::regex("template<(?:struct )?foo::my_template>")));
     }
     {
         std::ostringstream ss;
         ss << hana::experimental::print(
             hana::metafunction<foo::my_mf>
         );
-        BOOST_HANA_RUNTIME_CHECK(ss.str() == "metafunction<foo::my_mf>");
+        BOOST_HANA_RUNTIME_CHECK(std::regex_match(ss.str(),
+            std::regex("metafunction<(?:struct )?foo::my_mf>")));
     }
     {
         std::ostringstream ss;
         ss << hana::experimental::print(
             hana::metafunction_class<foo::my_mf_class>
         );
-        BOOST_HANA_RUNTIME_CHECK(ss.str() == "metafunction_class<foo::my_mf_class>");
+        BOOST_HANA_RUNTIME_CHECK(std::regex_match(ss.str(),
+            std::regex("metafunction_class<(?:struct )?foo::my_mf_class>")));
     }
 }
diff --git a/test/pair/empty_storage.cpp b/test/pair/empty_storage.cpp
index cdea66cb99..0000414856 100644
--- a/test/pair/empty_storage.cpp
+++ b/test/pair/empty_storage.cpp
@@ -8,16 +8,27 @@
 namespace hana = boost::hana;
 
 
+struct empty1 { };
+struct empty2 { };
+struct empty3 { };
+struct empty4 { };
+
 // Make sure the storage of a pair is compressed
-struct empty { };
-static_assert(sizeof(hana::pair<empty, int>) == sizeof(int), "");
-static_assert(sizeof(hana::pair<int, empty>) == sizeof(int), "");
+static_assert(sizeof(hana::pair<empty1, int>) == sizeof(int), "");
+static_assert(sizeof(hana::pair<int, empty1>) == sizeof(int), "");
 
 // Also make sure that a pair with only empty members is empty too. This is
 // important to ensure, for example, that a tuple of pairs of empty objects
 // will get the EBO.
-struct empty1 { };
-struct empty2 { };
 static_assert(std::is_empty<hana::pair<empty1, empty2>>{}, "");
 
+// Make sure that a pair of empty pairs is still empty.
+static_assert(std::is_empty<
+  hana::pair<hana::pair<empty1, empty2>, empty3>
+>{}, "");
+
+static_assert(std::is_empty<
+  hana::pair<hana::pair<empty1, empty2>, hana::pair<empty3, empty4>>
+>{}, "");
+
 int main() { }
diff --git a/test/tuple/empty_member.cpp b/test/tuple/empty_member.cpp
index 34fc623de7..1bab831852 100644
--- a/test/tuple/empty_member.cpp
+++ b/test/tuple/empty_member.cpp
@@ -12,22 +12,22 @@ struct B { };
 int main() {
     {
         using T = hana::tuple<int, A>;
-        static_assert((sizeof(T) == sizeof(int)), "");
+        static_assert(sizeof(T) == sizeof(int), "");
     }
     {
         using T = hana::tuple<A, int>;
-        static_assert((sizeof(T) == sizeof(int)), "");
+        static_assert(sizeof(T) == sizeof(int), "");
     }
     {
         using T = hana::tuple<A, int, B>;
-        static_assert((sizeof(T) == sizeof(int)), "");
+        static_assert(sizeof(T) == sizeof(int), "");
     }
     {
         using T = hana::tuple<A, B, int>;
-        static_assert((sizeof(T) == sizeof(int)), "");
+        static_assert(sizeof(T) == sizeof(int), "");
     }
     {
         using T = hana::tuple<int, A, B>;
-        static_assert((sizeof(T) == sizeof(int)), "");
+        static_assert(sizeof(T) == sizeof(int), "");
     }
 }
diff --git a/test/tuple/smart_ptr.cpp b/test/tuple/smart_ptr.cpp
index fe46a475c3..aea7dc8576 100644
--- a/test/tuple/smart_ptr.cpp
+++ b/test/tuple/smart_ptr.cpp
@@ -9,7 +9,6 @@ namespace hana = boost::hana;
 
 
 // Tuples of smart pointers; based on LLVM bug #18350
-// auto_ptr doesn't have a copy constructor that takes a const &, but tuple does.
 int main() {
     {
         hana::tuple<std::unique_ptr<char>> up;
@@ -21,9 +20,4 @@ int main() {
         hana::tuple<std::shared_ptr<char[]>> sp;
         hana::tuple<std::weak_ptr  <char[]>> wp;
     }
-    {
-        hana::tuple<std::unique_ptr<char[5]>> up;
-        hana::tuple<std::shared_ptr<char[5]>> sp;
-        hana::tuple<std::weak_ptr  <char[5]>> wp;
-    }
 }
diff --git a/test/type/integral.cpp b/test/type/integral.cpp
index db585f5803..e3159bbc3b 100644
--- a/test/type/integral.cpp
+++ b/test/type/integral.cpp
@@ -5,6 +5,7 @@
 #include <boost/hana/assert.hpp>
 #include <boost/hana/concept/metafunction.hpp>
 #include <boost/hana/equal.hpp>
+#include <boost/hana/not.hpp>
 #include <boost/hana/type.hpp>
 
 #include <type_traits>
@@ -58,6 +59,15 @@ static_assert(std::is_same<
     mfc::apply<x1, x2>::type
 >{}, "");
 
+// Make sure integral is SFINAE-friendly
+struct invalid_hana_metafunction {
+    template <typename ...> struct apply { /* missing type alias */ };
+};
+auto invalid_integral = hana::integral(invalid_hana_metafunction{});
+BOOST_HANA_CONSTANT_CHECK(hana::not_(
+    hana::is_valid(invalid_integral)(hana::type_c<void>, hana::type_c<void>)
+));
+
 
 int main() {
     // Make sure we can perform the call; we already made sure the return type was correct
diff --git a/test/type/metafunction.cpp b/test/type/metafunction.cpp
index 0c9a9383bf..aa52c1f38e 100644
--- a/test/type/metafunction.cpp
+++ b/test/type/metafunction.cpp
@@ -5,6 +5,7 @@
 #include <boost/hana/assert.hpp>
 #include <boost/hana/concept/metafunction.hpp>
 #include <boost/hana/equal.hpp>
+#include <boost/hana/not.hpp>
 #include <boost/hana/type.hpp>
 
 #include <type_traits>
@@ -56,6 +57,12 @@ static_assert(!valid_call(hana::metafunction<no_type>, hana::type_c<x1>), "");
 static_assert(hana::Metafunction<decltype(hana::metafunction<f>)>::value, "");
 static_assert(hana::Metafunction<decltype(hana::metafunction<f>)&>::value, "");
 
+// Make sure metafunction is SFINAE-friendly
+template <typename T> struct not_a_metafunction { };
+BOOST_HANA_CONSTANT_CHECK(hana::not_(
+    hana::is_valid(hana::metafunction<not_a_metafunction>)(hana::type_c<void>)
+));
+
 
 // Make sure we don't read from a non-constexpr variable
 int main() {
diff --git a/test/type/metafunction_class.cpp b/test/type/metafunction_class.cpp
index 5b33b00030..b0123708b1 100644
--- a/test/type/metafunction_class.cpp
+++ b/test/type/metafunction_class.cpp
@@ -5,6 +5,7 @@
 #include <boost/hana/assert.hpp>
 #include <boost/hana/concept/metafunction.hpp>
 #include <boost/hana/equal.hpp>
+#include <boost/hana/not.hpp>
 #include <boost/hana/type.hpp>
 
 #include <type_traits>
@@ -53,6 +54,16 @@ static_assert(!valid_call(hana::metafunction_class<no_type>, hana::type_c<x1>),
 static_assert(hana::Metafunction<decltype(hana::metafunction_class<f>)>::value, "");
 static_assert(hana::Metafunction<decltype(hana::metafunction_class<f>)&>::value, "");
 
+// Make sure metafunction_class is SFINAE-friendly
+struct not_a_mfc1 { template <typename ...> struct apply { }; };
+struct not_a_mfc2 { };
+BOOST_HANA_CONSTANT_CHECK(hana::not_(
+    hana::is_valid(hana::metafunction_class<not_a_mfc1>)(hana::type_c<void>)
+));
+BOOST_HANA_CONSTANT_CHECK(hana::not_(
+    hana::is_valid(hana::metafunction_class<not_a_mfc2>)(hana::type_c<void>)
+));
+
 
 // Make sure we don't read from a non-constexpr variable
 int main() {
diff --git a/test/type/template.cpp b/test/type/template.cpp
index a5d7142d62..6b35d35e73 100644
--- a/test/type/template.cpp
+++ b/test/type/template.cpp
@@ -5,6 +5,7 @@
 #include <boost/hana/assert.hpp>
 #include <boost/hana/concept/metafunction.hpp>
 #include <boost/hana/equal.hpp>
+#include <boost/hana/not.hpp>
 #include <boost/hana/type.hpp>
 
 #include <type_traits>
@@ -46,6 +47,11 @@ static_assert(hana::Metafunction<decltype(hana::template_<f>)&>::value, "");
 template <typename T> using alias = T;
 static_assert(hana::template_<alias>(hana::type_c<x1>) == hana::type_c<x1>, "");
 
+// Make sure template_ is SFINAE-friendly
+template <typename T> struct unary;
+BOOST_HANA_CONSTANT_CHECK(hana::not_(
+    hana::is_valid(hana::template_<unary>)(hana::type_c<void>, hana::type_c<void>)
+));
 
 // Make sure we don't read from a non-constexpr variable
 int main() {