diff --git a/example/applicative/ap.cpp b/example/applicative/ap.cpp
index 070dc03b9..4ab9e1d84 100644
--- a/example/applicative/ap.cpp
+++ b/example/applicative/ap.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
@@ -15,7 +15,7 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto f = _ + _;
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         ap(lift<List>(f), list(1, 2), list(3, 4, 5))
             ==
         list(
@@ -27,10 +27,10 @@ int main() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto a, auto b, auto c) {
         return a * b * c;
     };
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         ap(lift<Maybe>(g), just(1), just(2), just(3)) == just(1 * 2 * 3)
     );
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         ap(lift<Maybe>(g), just(1), nothing, just(3)) == nothing
     );
     //! [main]
diff --git a/example/applicative/lift.cpp b/example/applicative/lift.cpp
index e8039ee66..6bb685e00 100644
--- a/example/applicative/lift.cpp
+++ b/example/applicative/lift.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -12,7 +12,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(lift<List>('x') == list('x'));
-    BOOST_HANA_STATIC_ASSERT(lift<Maybe>('x') == just('x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<List>('x') == list('x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<Maybe>('x') == just('x'));
     //! [main]
 }
diff --git a/example/comparable/equal.cpp b/example/comparable/equal.cpp
index f36509f06..48808908a 100644
--- a/example/comparable/equal.cpp
+++ b/example/comparable/equal.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(equal(list(1, 2), list(1, 2)));
-    BOOST_HANA_STATIC_ASSERT(!equal('x', 'y'));
-    BOOST_HANA_STATIC_ASSERT(!equal(list(1, 2), 'y'));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(list(1, 2), list(1, 2)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal('x', 'y'));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(list(1, 2), 'y'));
     //! [main]
 }
diff --git a/example/comparable/not_equal.cpp b/example/comparable/not_equal.cpp
index 9484b3fa3..c878e4996 100644
--- a/example/comparable/not_equal.cpp
+++ b/example/comparable/not_equal.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(not_equal(list(1, 2), list(3)));
-    BOOST_HANA_STATIC_ASSERT(not_equal('x', 'y'));
-    BOOST_HANA_STATIC_ASSERT(not_equal(list(1, 2), 'y'));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_equal(list(1, 2), list(3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_equal('x', 'y'));
+    BOOST_HANA_CONSTANT_ASSERT(not_equal(list(1, 2), 'y'));
     //! [main]
 }
diff --git a/example/constant/comparable.cpp b/example/constant/comparable.cpp
index ce32351d5..d2c7aaa16 100644
--- a/example/constant/comparable.cpp
+++ b/example/constant/comparable.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,8 +16,8 @@ struct Person {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(integral<int, 1> == integral<long, 1>);
-    BOOST_HANA_STATIC_ASSERT(integral<int, 1> != integral<int, 2>);
-    BOOST_HANA_STATIC_ASSERT(integral<int, 1> != integral<int Person::*, &Person::age>);
+    BOOST_HANA_CONSTANT_ASSERT(integral<int, 1> == integral<long, 1>);
+    BOOST_HANA_CONSTANT_ASSERT(integral<int, 1> != integral<int, 2>);
+    BOOST_HANA_CONSTANT_ASSERT(integral<int, 1> != integral<int Person::*, &Person::age>);
 }
 //! [main]
diff --git a/example/core/binary_typeclass.cpp b/example/core/binary_typeclass.cpp
index d397e5220..93533ec04 100644
--- a/example/core/binary_typeclass.cpp
+++ b/example/core/binary_typeclass.cpp
@@ -6,11 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/bool.hpp>
 #include <boost/hana/core/typeclass.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <algorithm>
-#include <cassert>
 #include <string>
 #include <utility>
 #include <vector>
@@ -56,8 +55,8 @@ int main() {
 
     // We can now compare arbitrary containers
     // (not that it's brilliant to do so)
-    assert(similar(foo_vec, foo_str));
+    BOOST_HANA_RUNTIME_ASSERT(similar(foo_vec, foo_str));
 
     // And arbitrary stuff now compare unequal.
-    BOOST_HANA_STATIC_ASSERT(!similar(1, foo_str));
+    BOOST_HANA_CONSTANT_ASSERT(!similar(1, foo_str));
 }
diff --git a/example/core/disable.cpp b/example/core/disable.cpp
index 2a2852837..14d1abaeb 100644
--- a/example/core/disable.cpp
+++ b/example/core/disable.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/core/is_a.hpp>
 #include <boost/hana/core/typeclass.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
 #include <boost/hana/list/list.hpp>
 using namespace boost::hana;
@@ -17,8 +17,8 @@ namespace boost { namespace hana {
     struct Foldable::instance<StdTuple> : disable { };
 }}
 
-int main() {
-    // Usually, List should provide Foldable.
-    BOOST_HANA_STATIC_ASSERT(is_a<List, StdTuple>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Foldable, StdTuple>);
-}
+// Usually, List should provide Foldable.
+BOOST_HANA_CONSTANT_ASSERT(is_a<List, StdTuple>);
+BOOST_HANA_CONSTANT_ASSERT(!is_a<Foldable, StdTuple>);
+
+int main() { }
diff --git a/example/core/is_a.cpp b/example/core/is_a.cpp
index 5d5682501..1ad497131 100644
--- a/example/core/is_a.cpp
+++ b/example/core/is_a.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/bool.hpp>
 #include <boost/hana/comparable/comparable.hpp>
 #include <boost/hana/core/is_a.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/iterable/iterable.hpp>
@@ -24,10 +24,10 @@ using namespace boost::hana;
 
 int main() {
     //! [standard]
-    BOOST_HANA_STATIC_ASSERT( is_a<Foldable, Maybe>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Logical, Maybe>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Foldable, int>);
-    BOOST_HANA_STATIC_ASSERT( is_a<Comparable, int, long>);
+    BOOST_HANA_CONSTANT_ASSERT( is_a<Foldable, Maybe>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Logical, Maybe>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Foldable, int>);
+    BOOST_HANA_CONSTANT_ASSERT( is_a<Comparable, int, long>);
     //! [standard]
 
     //! [alternate]
@@ -37,9 +37,7 @@ int main() {
             auto row_is_correct = [=](auto row) {
                 return list(headers(head(row))...) == tail(row);
             };
-            auto typeclasses_match = all(row_is_correct, list(rows...));
-            static_assert(typeclasses_match(),
-            "type classes in the table below are wrong");
+            BOOST_HANA_CONSTANT_ASSERT(all(row_is_correct, list(rows...)));
         };
     };
 
diff --git a/example/core/to.cpp b/example/core/to.cpp
index 35d97edac..b19c27849 100644
--- a/example/core/to.cpp
+++ b/example/core/to.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/array.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
 #include <boost/hana/integral.hpp>
@@ -18,15 +18,15 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         to<List>(std::make_tuple(1, '2', 3.3)) == list(1, '2', 3.3)
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         to<List>(range(int_<1>, int_<4>)) == list(int_<1>, int_<2>, int_<3>)
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         to<List>(std::array<int, 3>{{1, 2, 3}}) == list(1, 2, 3)
     );
     //! [main]
diff --git a/example/core/unary_typeclass.cpp b/example/core/unary_typeclass.cpp
index 90b9a3064..22a8776ae 100644
--- a/example/core/unary_typeclass.cpp
+++ b/example/core/unary_typeclass.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/core/typeclass.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <type_traits>
 namespace hana = boost::hana;
@@ -19,11 +19,15 @@ struct Incrementable {
 };
 
 BOOST_HANA_CONSTEXPR_LAMBDA auto next = [](auto x) {
-    return Incrementable::instance<hana::datatype_t<decltype(x)>>::next_impl(x);
+    return Incrementable::instance<
+        hana::datatype_t<decltype(x)>
+    >::next_impl(x);
 };
 
 BOOST_HANA_CONSTEXPR_LAMBDA auto next_n = [](auto x, unsigned int n) {
-    return Incrementable::instance<hana::datatype_t<decltype(x)>>::next_n_impl(x, n);
+    return Incrementable::instance<
+        hana::datatype_t<decltype(x)>
+    >::next_n_impl(x, n);
 };
 
 struct Incrementable::next_mcd {
@@ -62,12 +66,12 @@ struct Incrementable::instance<T, hana::when<std::is_floating_point<T>{}>>
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(next(1) == 2);
-    BOOST_HANA_STATIC_ASSERT(next_n(1, 3) == 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(next(1) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(next_n(1, 3) == 4);
 
-    BOOST_HANA_STATIC_ASSERT(next(1l) == 2l);
-    BOOST_HANA_STATIC_ASSERT(next_n(1l, 3) == 4l);
+    BOOST_HANA_CONSTEXPR_ASSERT(next(1l) == 2l);
+    BOOST_HANA_CONSTEXPR_ASSERT(next_n(1l, 3) == 4l);
 
-    BOOST_HANA_STATIC_ASSERT(next(1.0) == 2.0);
-    BOOST_HANA_STATIC_ASSERT(next_n(1.0, 3) == 4.0);
+    BOOST_HANA_CONSTEXPR_ASSERT(next(1.0) == 2.0);
+    BOOST_HANA_CONSTEXPR_ASSERT(next_n(1.0, 3) == 4.0);
 }
diff --git a/example/ext/boost/mpl/integral_c/constant.cpp b/example/ext/boost/mpl/integral_c/constant.cpp
index 1b7319984..7acdbed3f 100644
--- a/example/ext/boost/mpl/integral_c/constant.cpp
+++ b/example/ext/boost/mpl/integral_c/constant.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/boost/mpl/integral_c.hpp>
 
 #include <boost/mpl/int.hpp>
@@ -20,8 +20,8 @@ int main() {
 
     static_assert(value(mpl::integral_c<int, 3>{}) == 3, "");
 
-    BOOST_HANA_STATIC_ASSERT(mpl::integral_c<int, 3>{} == mpl::int_<3>{});
-    BOOST_HANA_STATIC_ASSERT(mpl::integral_c<int, 3>{} == mpl::long_<3>{});
-    BOOST_HANA_STATIC_ASSERT(mpl::integral_c<int, 3>{} != mpl::int_<0>{});
+    BOOST_HANA_CONSTANT_ASSERT(mpl::integral_c<int, 3>{} == mpl::int_<3>{});
+    BOOST_HANA_CONSTANT_ASSERT(mpl::integral_c<int, 3>{} == mpl::long_<3>{});
+    BOOST_HANA_CONSTANT_ASSERT(mpl::integral_c<int, 3>{} != mpl::int_<0>{});
     //! [main]
 }
diff --git a/example/ext/boost/mpl/vector/comparable.cpp b/example/ext/boost/mpl/vector/comparable.cpp
index fa0e31d32..1f0327455 100644
--- a/example/ext/boost/mpl/vector/comparable.cpp
+++ b/example/ext/boost/mpl/vector/comparable.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
 #include <boost/mpl/vector.hpp>
@@ -15,11 +15,11 @@ namespace mpl = boost::mpl;
 int main() {
     //! [main]
     using namespace operators; // required to be able to == MPL vectors
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         mpl::vector2<int, char>{} == mpl::vector<int, char>{}
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         mpl::vector2<int, char>{} != mpl::vector<int, char, float>{}
     );
     //! [main]
diff --git a/example/ext/boost/mpl/vector/functor.cpp b/example/ext/boost/mpl/vector/functor.cpp
index b169451bf..b2e047dfe 100644
--- a/example/ext/boost/mpl/vector/functor.cpp
+++ b/example/ext/boost/mpl/vector/functor.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/type.hpp>
@@ -20,13 +20,13 @@ int main() {
     using namespace operators; // required to be able to == MPL vectors
     constexpr mpl::vector<int, char, float> types{};
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         fmap(metafunction<std::add_pointer>, types)
         ==
         mpl::vector<int*, char*, float*>{}
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         replace(trait<std::is_floating_point>, type<void>, types)
         ==
         mpl::vector<int, char, void>{}
diff --git a/example/ext/boost/mpl/vector/iterable.cpp b/example/ext/boost/mpl/vector/iterable.cpp
index c951acfc3..587fb7069 100644
--- a/example/ext/boost/mpl/vector/iterable.cpp
+++ b/example/ext/boost/mpl/vector/iterable.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/type.hpp>
@@ -19,11 +19,11 @@ int main() {
     //! [main]
     using namespace operators; // required to be able to == MPL vectors
 
-    BOOST_HANA_STATIC_ASSERT(head(mpl::vector<int, char, void>{}) == type<int>);
+    BOOST_HANA_CONSTANT_ASSERT(head(mpl::vector<int, char, void>{}) == type<int>);
 
-    BOOST_HANA_STATIC_ASSERT(tail(mpl::vector<int, char, void>{}) == mpl::vector<char, void>{});
+    BOOST_HANA_CONSTANT_ASSERT(tail(mpl::vector<int, char, void>{}) == mpl::vector<char, void>{});
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         drop_while(trait<std::is_floating_point>, mpl::vector<float, double const, int, float&>{})
         ==
         mpl::vector<int, float&>{}
diff --git a/example/ext/boost/mpl/vector/list.cpp b/example/ext/boost/mpl/vector/list.cpp
index af7fd5464..3f6eda7a9 100644
--- a/example/ext/boost/mpl/vector/list.cpp
+++ b/example/ext/boost/mpl/vector/list.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/type.hpp>
@@ -19,14 +19,14 @@ int main() {
     //! [main]
     using namespace operators; // required to be able to == MPL vectors
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         cons(type<int>, mpl::vector<char>{}) == mpl::vector<int, char>{}
     );
 
     // error: only Types can go in a MPL vector
     // cons(1, mpl::vector<int>{});
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         filter(trait<std::is_integral>, mpl::vector<int, float, char, void>{})
         ==
         mpl::vector<int, char>{}
diff --git a/example/foldable/count.cpp b/example/foldable/count.cpp
index 3fef5ccdc..e31edbc18 100644
--- a/example/foldable/count.cpp
+++ b/example/foldable/count.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integer_list.hpp>
@@ -27,10 +27,10 @@ int main() {
     constexpr auto types = type_list<int, char, long, short, char, double>;
     constexpr auto ints = integer_list<int, 1, 2, 3>;
 
-    BOOST_HANA_STATIC_ASSERT(count(odd, ints) == 2_c);
+    BOOST_HANA_CONSTANT_ASSERT(count(odd, ints) == 2_c);
 
-    BOOST_HANA_STATIC_ASSERT(count(trait<std::is_floating_point>, types) == 1_c);
-    BOOST_HANA_STATIC_ASSERT(count(_ == type<char>, types) == 2_c);
-    BOOST_HANA_STATIC_ASSERT(count(_ == type<void>, types) == 0_c);
+    BOOST_HANA_CONSTANT_ASSERT(count(trait<std::is_floating_point>, types) == 1_c);
+    BOOST_HANA_CONSTANT_ASSERT(count(_ == type<char>, types) == 2_c);
+    BOOST_HANA_CONSTANT_ASSERT(count(_ == type<void>, types) == 0_c);
     //! [main]
 }
diff --git a/example/foldable/length.cpp b/example/foldable/length.cpp
index 196866773..086bc13d5 100644
--- a/example/foldable/length.cpp
+++ b/example/foldable/length.cpp
@@ -4,7 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
+#include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -12,10 +13,10 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(length(list()) == 0);
-    BOOST_HANA_STATIC_ASSERT(length(list(1, '2', 3.0)) == 3);
+    BOOST_HANA_CONSTANT_ASSERT(length(list()) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(1, '2', 3.0)) == int_<3>);
 
-    BOOST_HANA_STATIC_ASSERT(length(nothing) == 0);
-    BOOST_HANA_STATIC_ASSERT(length(just('x')) == 1);
+    BOOST_HANA_CONSTANT_ASSERT(length(nothing) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(just('x')) == int_<1>);
     //! [main]
 }
diff --git a/example/foldable/maximum.cpp b/example/foldable/maximum.cpp
index 9dc56d1e2..d979a5795 100644
--- a/example/foldable/maximum.cpp
+++ b/example/foldable/maximum.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -12,7 +12,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         maximum(integer_list<int, -1, 0, 2, -4, 6, 9>) == int_<9>
     );
     //! [main]
diff --git a/example/foldable/minimum.cpp b/example/foldable/minimum.cpp
index 9d78aed56..4bef33795 100644
--- a/example/foldable/minimum.cpp
+++ b/example/foldable/minimum.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -12,7 +12,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         minimum(integer_list<int, -1, 0, 2, -4, 6, 9>) == int_<-4>
     );
     //! [main]
diff --git a/example/foldable/product.cpp b/example/foldable/product.cpp
index 17029d2e3..475d587b5 100644
--- a/example/foldable/product.cpp
+++ b/example/foldable/product.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/range.hpp>
@@ -13,11 +13,11 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         product(range(int_<1>, int_<6>)) == int_<1 * 2 * 3 * 4 * 5>
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         product(list(1, int_<3>, long_<-5>, 9)) == 1 * 3 * -5 * 9
     );
     //! [main]
diff --git a/example/foldable/sum.cpp b/example/foldable/sum.cpp
index 0e49b86ab..d3c12adff 100644
--- a/example/foldable/sum.cpp
+++ b/example/foldable/sum.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/range.hpp>
@@ -13,11 +13,11 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         sum(range(int_<1>, int_<6>)) == int_<1 + 2 + 3 + 4 + 5>
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         sum(list(1, int_<3>, long_<-5>, 9)) == 1 + 3 - 5 + 9
     );
     //! [main]
diff --git a/example/foldable/unpack_idiom.cpp b/example/foldable/unpack_idiom.cpp
index 95d96dd94..07d255b85 100644
--- a/example/foldable/unpack_idiom.cpp
+++ b/example/foldable/unpack_idiom.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -20,6 +20,6 @@ int main() {
     // Would be `boost::fusion::make_fused(add)` in Boost.Fusion.
     BOOST_HANA_CONSTEXPR_LAMBDA auto add_seq = partial(unpack, add);
 
-    BOOST_HANA_STATIC_ASSERT(add_seq(list(1, 2)) == add(1, 2));
+    BOOST_HANA_CONSTEXPR_ASSERT(add_seq(list(1, 2)) == add(1, 2));
     //! [main]
 }
diff --git a/example/functional/always/basic.cpp b/example/functional/always/basic.cpp
index 3bd385722..0eee3193b 100644
--- a/example/functional/always/basic.cpp
+++ b/example/functional/always/basic.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(always(1)() == 1);
-    BOOST_HANA_STATIC_ASSERT(always('2')(1, 2, 3) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(always(1)() == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(always('2')(1, 2, 3) == '2');
     //! [main]
 }
diff --git a/example/functional/apply.cpp b/example/functional/apply.cpp
index 8e8e8618e..1a03ed7d6 100644
--- a/example/functional/apply.cpp
+++ b/example/functional/apply.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -16,6 +16,6 @@ int main() {
         return x + y;
     };
 
-    BOOST_HANA_STATIC_ASSERT(apply(plus, 1, 3) == 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(plus, 1, 3) == 4);
     //! [main]
 }
diff --git a/example/functional/arg.cpp b/example/functional/arg.cpp
index d0d168d6d..6988904c3 100644
--- a/example/functional/arg.cpp
+++ b/example/functional/arg.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -12,9 +12,9 @@ using namespace boost::hana;
 int main() {
     //! [main]
     // arg<0>(1, '2', 3.3); // static assertion (regardless of the number of arguments)
-    BOOST_HANA_STATIC_ASSERT(arg<1>(1, '2', 3.3) == 1);
-    BOOST_HANA_STATIC_ASSERT(arg<2>(1, '2', 3.3) == '2');
-    BOOST_HANA_STATIC_ASSERT(arg<3>(1, '2', 3.3) == 3.3);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<1>(1, '2', 3.3) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<2>(1, '2', 3.3) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<3>(1, '2', 3.3) == 3.3);
     // arg<4>(1, '2', 3.3); // static assertion
     //! [main]
 }
diff --git a/example/functional/compose.cpp b/example/functional/compose.cpp
index c39d9d804..b12592cf7 100644
--- a/example/functional/compose.cpp
+++ b/example/functional/compose.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -20,6 +20,6 @@ int main() {
         return x + 1;
     };
 
-    BOOST_HANA_STATIC_ASSERT(compose(to_char, increment)(3) == '4');
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(to_char, increment)(3) == '4');
     //! [main]
 }
diff --git a/example/functional/curry.cpp b/example/functional/curry.cpp
index 7e9e67aaa..3f0f41f9d 100644
--- a/example/functional/curry.cpp
+++ b/example/functional/curry.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -16,9 +16,9 @@ int main() {
         return x + y + z;
     };
 
-    BOOST_HANA_STATIC_ASSERT(curry<3>(add)(1)(2)(3) == 1 + 2 + 3);
-    BOOST_HANA_STATIC_ASSERT(curry<3>(add)(1)(2, 3) == curry<3>(add)(1)(2)(3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(add)(1, 2, 3) == curry<3>(add)(1)(2)(3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(add)(1)(2)(3) == 1 + 2 + 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(add)(1)(2, 3) == curry<3>(add)(1)(2)(3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(add)(1, 2, 3) == curry<3>(add)(1)(2)(3));
     //! [main]
 
 
@@ -27,6 +27,6 @@ int main() {
         return 2;
     };
 
-    BOOST_HANA_STATIC_ASSERT(curry<0>(two)() == two());
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<0>(two)() == two());
     //! [curry0]
 }
diff --git a/example/functional/demux.cpp b/example/functional/demux.cpp
index 2b27b996d..cb8335d93 100644
--- a/example/functional/demux.cpp
+++ b/example/functional/demux.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 
 #include <tuple>
@@ -18,7 +18,7 @@ int main() {
         return std::make_tuple(xs...);
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         demux(make_tuple, _ + _, _ - _, _ * _, _ / _)(10, 4)
         ==
         make_tuple(10 + 4, 10 - 4, 10 * 4, 10 / 4)
diff --git a/example/functional/fix.cpp b/example/functional/fix.cpp
index ada29553e..770d52dd7 100644
--- a/example/functional/fix.cpp
+++ b/example/functional/fix.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -17,6 +17,6 @@ int main() {
         else        return n * fact(n - 1);
     });
 
-    BOOST_HANA_STATIC_ASSERT(factorial(5) == 120);
+    BOOST_HANA_CONSTEXPR_ASSERT(factorial(5) == 120);
     //! [main]
 }
diff --git a/example/functional/flip.cpp b/example/functional/flip.cpp
index 4733d611a..dd7983539 100644
--- a/example/functional/flip.cpp
+++ b/example/functional/flip.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -16,10 +16,10 @@ int main() {
         return x - y - z;
     };
 
-    BOOST_HANA_STATIC_ASSERT(minus(3, 0) == 3 - 0);
-    BOOST_HANA_STATIC_ASSERT(flip(minus)(3, 0) == 0 - 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(minus(3, 0) == 3 - 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(minus)(3, 0) == 0 - 3);
 
-    BOOST_HANA_STATIC_ASSERT(minus(3, 0, 1) == 3 - 0 - 1);
-    BOOST_HANA_STATIC_ASSERT(flip(minus)(3, 0, 1) == 0 - 3 - 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(minus(3, 0, 1) == 3 - 0 - 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(minus)(3, 0, 1) == 0 - 3 - 1);
     //! [main]
 }
diff --git a/example/functional/id.cpp b/example/functional/id.cpp
index bcca34418..5688993fe 100644
--- a/example/functional/id.cpp
+++ b/example/functional/id.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(id(1) == 1);
-    BOOST_HANA_STATIC_ASSERT(id('1') == '1');
+    BOOST_HANA_CONSTEXPR_ASSERT(id(1) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(id('1') == '1');
     //! [main]
 }
diff --git a/example/functional/lockstep.cpp b/example/functional/lockstep.cpp
index be8dc9e6d..9b46747ec 100644
--- a/example/functional/lockstep.cpp
+++ b/example/functional/lockstep.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -24,6 +24,6 @@ int main() {
         return x + 1;
     };
 
-    BOOST_HANA_STATIC_ASSERT(lockstep(plus, to_int, inc)('3', 4) == 3 + 5);
+    BOOST_HANA_CONSTEXPR_ASSERT(lockstep(plus, to_int, inc)('3', 4) == 3 + 5);
     //! [main]
 }
diff --git a/example/functional/on/infix.cpp b/example/functional/on/infix.cpp
index 4297c8b64..122e23cea 100644
--- a/example/functional/on/infix.cpp
+++ b/example/functional/on/infix.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -22,7 +22,7 @@ int main() {
         pair(int_<2>, 9876)
     ));
 
-    BOOST_HANA_STATIC_ASSERT(sorted == list(
+    BOOST_HANA_CONSTEXPR_ASSERT(sorted == list(
         pair(int_<1>, type<void>),
         pair(int_<2>, 9876),
         pair(int_<3>, 'x')
diff --git a/example/functional/on/multiply.cpp b/example/functional/on/multiply.cpp
index 09fdb2efe..8a44768e0 100644
--- a/example/functional/on/multiply.cpp
+++ b/example/functional/on/multiply.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -20,6 +20,6 @@ int main() {
         return x * y;
     };
 
-    BOOST_HANA_STATIC_ASSERT(on(multiply, increment)(2, 4) == 3 * 5);
+    BOOST_HANA_CONSTEXPR_ASSERT(on(multiply, increment)(2, 4) == 3 * 5);
     //! [main]
 }
diff --git a/example/functional/on/plus.cpp b/example/functional/on/plus.cpp
index b2118a2c4..663ac2426 100644
--- a/example/functional/on/plus.cpp
+++ b/example/functional/on/plus.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
@@ -19,6 +19,6 @@ int main() {
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto x = pair(1, 2);
     BOOST_HANA_CONSTEXPR_LAMBDA auto y = pair(10, 20);
-    BOOST_HANA_STATIC_ASSERT(on(plus, first)(x, y) == 1 + 10);
+    BOOST_HANA_CONSTEXPR_ASSERT(on(plus, first)(x, y) == 1 + 10);
     //! [main]
 }
diff --git a/example/functional/partial.cpp b/example/functional/partial.cpp
index 14b7d6c52..24a37953f 100644
--- a/example/functional/partial.cpp
+++ b/example/functional/partial.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -18,6 +18,6 @@ int main() {
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto increment = partial(plus, 1);
 
-    BOOST_HANA_STATIC_ASSERT(increment(2) == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(increment(2) == 3);
     //! [main]
 }
diff --git a/example/functional/placeholder.cpp b/example/functional/placeholder.cpp
index 1892d5f6f..440cb962b 100644
--- a/example/functional/placeholder.cpp
+++ b/example/functional/placeholder.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -13,15 +13,15 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto plus = _ + _;
-    BOOST_HANA_STATIC_ASSERT(plus(1, 2) == 1 + 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(plus(1, 2) == 1 + 2);
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto increment = _ + 1;
-    BOOST_HANA_STATIC_ASSERT(increment(1) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(increment(1) == 2);
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto double_ = 2 * _;
-    BOOST_HANA_STATIC_ASSERT(double_(1) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(double_(1) == 2);
 
     // Extra arguments are ignored.
-    BOOST_HANA_STATIC_ASSERT(double_(1, "ignored") == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(double_(1, "ignored") == 2);
     //! [main]
 }
diff --git a/example/functor/adjust.cpp b/example/functor/adjust.cpp
index 9ba9fdb97..eee3889ef 100644
--- a/example/functor/adjust.cpp
+++ b/example/functor/adjust.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -20,7 +20,7 @@ int main() {
         return -x;
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         adjust(negative, negate, list(-3, -2, -1, 0, 1, 2, 3))
         ==
         list(3, 2, 1, 0, 1, 2, 3)
diff --git a/example/functor/fill.cpp b/example/functor/fill.cpp
index d5ef159dd..e3ce6b3e3 100644
--- a/example/functor/fill.cpp
+++ b/example/functor/fill.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -12,11 +12,11 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         fill('x', list(1, '2', 3.3, nullptr)) == list('x', 'x', 'x', 'x')
     );
 
-    BOOST_HANA_STATIC_ASSERT(fill('x', nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(fill('x', just('y')) == just('x'));
+    BOOST_HANA_CONSTANT_ASSERT(fill('x', nothing) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(fill('x', just('y')) == just('x'));
     //! [main]
 }
diff --git a/example/functor/fmap.cpp b/example/functor/fmap.cpp
index 0182524a4..f42b22f9c 100644
--- a/example/functor/fmap.cpp
+++ b/example/functor/fmap.cpp
@@ -4,13 +4,12 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/type.hpp>
 #include <boost/hana/type_list.hpp>
 
-#include <cassert>
 #include <sstream>
 #include <string>
 #include <type_traits>
@@ -23,18 +22,18 @@ int main() {
         return (std::ostringstream{} << x).str();
     };
 
-    assert(
+    BOOST_HANA_RUNTIME_ASSERT(
         fmap(to_string, list(1, '2', "345", std::string{"67"}))
         ==
         list("1", "2", "345", "67")
     );
 
-    BOOST_HANA_STATIC_ASSERT(fmap(to_string, nothing) == nothing);
-    assert(fmap(to_string, just(123)) == just("123"));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(to_string, nothing) == nothing);
+    BOOST_HANA_RUNTIME_ASSERT(fmap(to_string, just(123)) == just("123"));
     //! [to_string]
 
     //! [add_pointer]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         fmap(template_<std::add_pointer_t>, type_list<void, int(), char[10]>)
                 ==
         type_list<void*, int(*)(), char(*)[10]>
diff --git a/example/functor/replace.cpp b/example/functor/replace.cpp
index ce23bbbff..118e12054 100644
--- a/example/functor/replace.cpp
+++ b/example/functor/replace.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -16,7 +16,7 @@ int main() {
         return x < 0;
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         replace(negative, 0, list(-3, -2, -1, 0, 1, 2, 3))
         ==
         list(0, 0, 0, 0, 1, 2, 3)
diff --git a/example/integer_list/foldable/foldr.cpp b/example/integer_list/foldable/foldr.cpp
index 72130bf4b..5e58ef606 100644
--- a/example/integer_list/foldable/foldr.cpp
+++ b/example/integer_list/foldable/foldr.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -21,6 +21,6 @@ int main() {
         return if_(n < 0_c, cons(n, acc), acc);
     };
 
-    BOOST_HANA_STATIC_ASSERT(foldr(keep_negatives, integer_list<int>, numbers) == negatives);
+    BOOST_HANA_CONSTANT_ASSERT(foldr(keep_negatives, integer_list<int>, numbers) == negatives);
     //! [main]
 }
diff --git a/example/integer_list/integer_list.cpp b/example/integer_list/integer_list.cpp
index f251b0615..4ef961f8a 100644
--- a/example/integer_list/integer_list.cpp
+++ b/example/integer_list/integer_list.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -13,7 +13,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(to<List>(integer_list<int, 0, 1, 2>) == list(int_<0>, int_<1>, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(head(integer_list<int, 0, 1, 2>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(to<List>(integer_list<int, 0, 1, 2>) == list(int_<0>, int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(head(integer_list<int, 0, 1, 2>) == int_<0>);
     //! [main]
 }
diff --git a/example/integral/comparable.cpp b/example/integral/comparable.cpp
index a930052b9..b936d3f97 100644
--- a/example/integral/comparable.cpp
+++ b/example/integral/comparable.cpp
@@ -4,17 +4,17 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(equal(int_<1>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_equal(int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(equal(int_<1>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(not_equal(int_<1>, int_<2>));
 
-    BOOST_HANA_STATIC_ASSERT(equal(int_<1>, long_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_equal(int_<1>, long_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(equal(int_<1>, long_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(not_equal(int_<1>, long_<2>));
     //! [main]
 }
diff --git a/example/integral/literals.cpp b/example/integral/literals.cpp
index 2e88fe43a..b57d24e15 100644
--- a/example/integral/literals.cpp
+++ b/example/integral/literals.cpp
@@ -4,22 +4,18 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
-#include <boost/hana/type.hpp>
 using namespace boost::hana;
-using namespace literals;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(1234_c == llong<1234>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(1234_c) == decltype_(llong<1234>));
+    using namespace literals;
 
-    BOOST_HANA_STATIC_ASSERT(-1234_c == llong<-1234>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(-1234_c) == decltype_(llong<-1234>));
-
-    BOOST_HANA_STATIC_ASSERT(sum(list(1_c, 2_c, 3_c, 4_c)) == 10_c);
+    BOOST_HANA_CONSTANT_ASSERT(1234_c == llong<1234>);
+    BOOST_HANA_CONSTANT_ASSERT(-1234_c == llong<-1234>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(list(1_c, 2_c, 3_c, 4_c)) == 10_c);
     //! [main]
 }
diff --git a/example/integral/operators.cpp b/example/integral/operators.cpp
index 755ec1f79..9c30a73e1 100644
--- a/example/integral/operators.cpp
+++ b/example/integral/operators.cpp
@@ -4,20 +4,17 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
-#include <boost/hana/type.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(int_<1> + int_<3> == int_<4>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(int_<1> + int_<3>) == decltype_(int_<4>));
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> + int_<3> == int_<4>);
 
     // Mixed-type operations are supported:
-    BOOST_HANA_STATIC_ASSERT(decltype_(size_t<3> * ushort<5>) == decltype_(size_t<15>));
-    BOOST_HANA_STATIC_ASSERT(decltype_(size_t<15>) != decltype_(int_<15>));
-    BOOST_HANA_STATIC_ASSERT(size_t<3> * ushort<5> == int_<15>);
+    BOOST_HANA_CONSTANT_ASSERT(size_t<3> * ushort<5> == size_t<15>);
+    BOOST_HANA_CONSTANT_ASSERT(size_t<15> == int_<15>);
     //! [main]
 }
diff --git a/example/integral/orderable.cpp b/example/integral/orderable.cpp
index f02138e26..706b706fc 100644
--- a/example/integral/orderable.cpp
+++ b/example/integral/orderable.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(less(int_<-3>, int_<3>));
-    BOOST_HANA_STATIC_ASSERT(max(int_<-3>, long_<2>) == long_<2>);
-    BOOST_HANA_STATIC_ASSERT(min(int_<-3>, long_<2>) == int_<-3>);
+    BOOST_HANA_CONSTANT_ASSERT(less(int_<-3>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(max(int_<-3>, long_<2>) == long_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(min(int_<-3>, long_<2>) == int_<-3>);
     //! [main]
 }
diff --git a/example/iterable/at.cpp b/example/iterable/at.cpp
index d5aa9a794..7ea324a5d 100644
--- a/example/iterable/at.cpp
+++ b/example/iterable/at.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -12,8 +12,8 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, list(0, '1', 2.0)) == 0);
-    BOOST_HANA_STATIC_ASSERT(at(int_<1>, list(0, '1', 2.0)) == '1');
-    BOOST_HANA_STATIC_ASSERT(at(int_<2>, list(0, '1', 2.0)) == 2.0);
+    BOOST_HANA_CONSTEXPR_ASSERT(at(int_<0>, list(0, '1', 2.0)) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(at(int_<1>, list(0, '1', 2.0)) == '1');
+    BOOST_HANA_CONSTEXPR_ASSERT(at(int_<2>, list(0, '1', 2.0)) == 2.0);
     //! [main]
 }
diff --git a/example/iterable/drop.cpp b/example/iterable/drop.cpp
index 23e72f2ff..20b3cd014 100644
--- a/example/iterable/drop.cpp
+++ b/example/iterable/drop.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -14,10 +14,10 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto xs = list(0, '1', 2.0);
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, xs) == xs);
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, xs) == list('1', 2.0));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, xs) == list(2.0));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<3>, xs) == list());
-    BOOST_HANA_STATIC_ASSERT(drop(int_<4>, xs) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(drop(int_<0>, xs) == xs);
+    BOOST_HANA_CONSTEXPR_ASSERT(drop(int_<1>, xs) == list('1', 2.0));
+    BOOST_HANA_CONSTEXPR_ASSERT(drop(int_<2>, xs) == list(2.0));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<3>, xs) == list());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<4>, xs) == list());
     //! [main]
 }
diff --git a/example/iterable/drop_until.cpp b/example/iterable/drop_until.cpp
index b970f5da0..3ff8d168a 100644
--- a/example/iterable/drop_until.cpp
+++ b/example/iterable/drop_until.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/range.hpp>
@@ -19,11 +19,11 @@ int main() {
         return x > int_<0>;
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         drop_until(positive, range(int_<-3>, int_<6>)) == range(int_<1>, int_<6>)
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         drop_until(positive, list(1_c, -2_c, 4_c, 5_c)) == list(1_c, -2_c, 4_c, 5_c)
     );
     //! [main]
diff --git a/example/iterable/drop_while.cpp b/example/iterable/drop_while.cpp
index fc2ba7107..914c9c25e 100644
--- a/example/iterable/drop_while.cpp
+++ b/example/iterable/drop_while.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/range.hpp>
@@ -19,11 +19,11 @@ int main() {
         return x < int_<0>;
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         drop_while(negative, range(int_<-3>, int_<6>)) == range(int_<0>, int_<6>)
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         drop_while(negative, list(1_c, -2_c, 4_c, 5_c)) == list(1_c, -2_c, 4_c, 5_c)
     );
     //! [main]
diff --git a/example/iterable/head.cpp b/example/iterable/head.cpp
index ef814e172..6098a96fd 100644
--- a/example/iterable/head.cpp
+++ b/example/iterable/head.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(head(list(1, '2', 3.3, nullptr)) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(list(1, '2', 3.3, nullptr)) == 1);
     //! [main]
 }
diff --git a/example/iterable/is_empty.cpp b/example/iterable/is_empty.cpp
index d7330e203..3ed454233 100644
--- a/example/iterable/is_empty.cpp
+++ b/example/iterable/is_empty.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
-int main() {
-    //! [main]
-    BOOST_HANA_STATIC_ASSERT(!is_empty(list(1, '2')));
-    BOOST_HANA_STATIC_ASSERT( is_empty(list()));
-    //! [main]
-}
+//! [main]
+BOOST_HANA_CONSTANT_ASSERT(!is_empty(list(1, '2')));
+BOOST_HANA_CONSTANT_ASSERT( is_empty(list()));
+//! [main]
+
+int main() { }
diff --git a/example/iterable/last.cpp b/example/iterable/last.cpp
index 37e425b8a..fe71069b3 100644
--- a/example/iterable/last.cpp
+++ b/example/iterable/last.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(last(list(1, '2', 3.3, nullptr)) == nullptr);
+    BOOST_HANA_CONSTEXPR_ASSERT(last(list(1, '2', 3.3, nullptr)) == nullptr);
     //! [main]
 }
diff --git a/example/iterable/tail.cpp b/example/iterable/tail.cpp
index 0011d6c22..6f8e397c3 100644
--- a/example/iterable/tail.cpp
+++ b/example/iterable/tail.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         tail(list(1, '2', 3.3, nullptr)) == list('2', 3.3, nullptr)
     );
     //! [main]
diff --git a/example/lazy/functor/fmap.cpp b/example/lazy/functor/fmap.cpp
index f39e603ad..6173adf71 100644
--- a/example/lazy/functor/fmap.cpp
+++ b/example/lazy/functor/fmap.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/lazy.hpp>
 using namespace boost::hana;
 
@@ -20,7 +20,7 @@ int main() {
         return 1 / x;
     };
 
-    BOOST_HANA_STATIC_ASSERT(eval(fmap(double_, lazy(one_over)(4))) == 1 / 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(eval(fmap(double_, lazy(one_over)(4))) == 1 / 2);
 
     fmap(double_, lazy(one_over)(0)); // never evaluated
     //! [main]
diff --git a/example/lazy/lazy.cpp b/example/lazy/lazy.cpp
index 2cd25bc29..ac9e5713c 100644
--- a/example/lazy/lazy.cpp
+++ b/example/lazy/lazy.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/lazy.hpp>
 using namespace boost::hana;
 
@@ -20,6 +20,6 @@ int main() {
         return x + 1;
     });
 
-    BOOST_HANA_STATIC_ASSERT(eval(if_(false_, f(0), g(0))) == 0 + 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(eval(if_(false_, f(0), g(0))) == 0 + 1);
     //! [main]
 }
diff --git a/example/list/applicative.cpp b/example/list/applicative.cpp
index a961654d0..392d337ad 100644
--- a/example/list/applicative.cpp
+++ b/example/list/applicative.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -17,12 +17,12 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(lift<List>('x') == list('x'));
-    BOOST_HANA_STATIC_ASSERT(lift<StdTuple>('x') == std::make_tuple('x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<List>('x') == list('x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<StdTuple>('x') == std::make_tuple('x'));
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto f = pair;
     BOOST_HANA_CONSTEXPR_LAMBDA auto g = flip(pair);
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         ap(list(f, g), list(1, 2, 3), list('a', 'b'))
             ==
         list(
diff --git a/example/list/comparable.cpp b/example/list/comparable.cpp
index f51d89f2c..0897ebc7b 100644
--- a/example/list/comparable.cpp
+++ b/example/list/comparable.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(list(1, 2, 3) == list(1, 2, 3));
-    BOOST_HANA_STATIC_ASSERT(list(1, 2, 3) != list(1, 2, 3, 4));
+    BOOST_HANA_CONSTEXPR_ASSERT(list(1, 2, 3) == list(1, 2, 3));
+    BOOST_HANA_CONSTEXPR_ASSERT(list(1, 2, 3) != list(1, 2, 3, 4));
     //! [main]
 }
diff --git a/example/list/concat.cpp b/example/list/concat.cpp
index f9ad06ca3..d48e84416 100644
--- a/example/list/concat.cpp
+++ b/example/list/concat.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -13,7 +13,7 @@ using namespace literals;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         concat(list(1, '2'), list(3.3, 4_c)) == list(1, '2', 3.3, 4_c)
     );
     //! [main]
diff --git a/example/list/cons.cpp b/example/list/cons.cpp
index 5b9238151..b0d09555b 100644
--- a/example/list/cons.cpp
+++ b/example/list/cons.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(cons(1, list()) == list(1));
-    BOOST_HANA_STATIC_ASSERT(cons(1, list('2', 3.3)) == list(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(cons(1, cons('2', cons(3.3, list()))) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(1, list()) == list(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(1, list('2', 3.3)) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(1, cons('2', cons(3.3, list()))) == list(1, '2', 3.3));
     //! [main]
 }
diff --git a/example/list/filter.cpp b/example/list/filter.cpp
index 490c38d36..a7eb28bc9 100644
--- a/example/list/filter.cpp
+++ b/example/list/filter.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -15,6 +15,6 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(filter(trait_<std::is_integral>, list(1, 2.0, 3, 4.0)) == list(1, 3));
+    BOOST_HANA_CONSTEXPR_ASSERT(filter(trait_<std::is_integral>, list(1, 2.0, 3, 4.0)) == list(1, 3));
     //! [main]
 }
diff --git a/example/list/init.cpp b/example/list/init.cpp
index 6d0a1844e..2da5090db 100644
--- a/example/list/init.cpp
+++ b/example/list/init.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -13,7 +13,7 @@ using namespace literals;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(init(list(1)) == list());
-    BOOST_HANA_STATIC_ASSERT(init(list(1, '2', 3.3, 4_c)) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTANT_ASSERT(init(list(1)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(1, '2', 3.3, 4_c)) == list(1, '2', 3.3));
     //! [main]
 }
diff --git a/example/list/into.cpp b/example/list/into.cpp
index d4939177d..81ee67ca0 100644
--- a/example/list/into.cpp
+++ b/example/list/into.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(into<List>() == list());
-    BOOST_HANA_STATIC_ASSERT(into<List>(1, '2', 3.3) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTANT_ASSERT(into<List>() == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(into<List>(1, '2', 3.3) == list(1, '2', 3.3));
     //! [main]
 }
diff --git a/example/list/iterable/overview.cpp b/example/list/iterable/overview.cpp
index ee509053f..7d67311e8 100644
--- a/example/list/iterable/overview.cpp
+++ b/example/list/iterable/overview.cpp
@@ -4,16 +4,16 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(head(list(1, '2', "3")) == 1);
-    BOOST_HANA_STATIC_ASSERT(tail(list(1, '2', "3")) == list('2', "3"));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(list(1, '2', "3")));
-    BOOST_HANA_STATIC_ASSERT(is_empty(list()));
+    BOOST_HANA_CONSTEXPR_ASSERT(head(list(1, '2', 3.3)) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(tail(list(1, '2', 3.3)) == list('2', 3.3));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(list(1, '2', 3.3)));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(list()));
     //! [main]
 }
diff --git a/example/list/monad.cpp b/example/list/monad.cpp
index 0112073ea..e60f15522 100644
--- a/example/list/monad.cpp
+++ b/example/list/monad.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -13,9 +13,9 @@ int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) { return list(x, -x); };
 
-    BOOST_HANA_STATIC_ASSERT((list(1, 2, 3) | f) == list(1, -1, 2, -2, 3, -3));
+    BOOST_HANA_CONSTEXPR_ASSERT((list(1, 2, 3) | f) == list(1, -1, 2, -2, 3, -3));
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         flatten(list(list(1, 2), list(3, 4), list(list(5, 6)))) == list(1, 2, 3, 4, list(5, 6))
     );
     //! [main]
diff --git a/example/list/nil.cpp b/example/list/nil.cpp
index 92254d61a..3e43fd7ee 100644
--- a/example/list/nil.cpp
+++ b/example/list/nil.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(nil<List> == list());
+    BOOST_HANA_CONSTANT_ASSERT(nil<List> == list());
     //! [main]
 }
diff --git a/example/list/partition.cpp b/example/list/partition.cpp
index 2321c0ec5..74178cf15 100644
--- a/example/list/partition.cpp
+++ b/example/list/partition.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
@@ -17,30 +17,30 @@ Distributed under the Boost Software License, Version 1.0.
 using namespace boost::hana;
 
 
-int main() {
-    //! [ints]
-    BOOST_HANA_CONSTEXPR_LAMBDA auto odd = [](auto x) {
-        return x % int_<2> != int_<0>;
-    };
+//! [ints]
+BOOST_HANA_CONSTEXPR_LAMBDA auto odd = [](auto x) {
+    return x % int_<2> != int_<0>;
+};
 
-    BOOST_HANA_STATIC_ASSERT(
-        partition(odd, integer_list<int, 1, 2, 3, 4, 5, 6, 7>)
-        ==
-        pair(
-            integer_list<int, 1, 3, 5, 7>,
-            integer_list<int, 2, 4, 6>
-        )
-    );
-    //! [ints]
+BOOST_HANA_CONSTANT_ASSERT(
+    partition(odd, integer_list<int, 1, 2, 3, 4, 5, 6, 7>)
+    ==
+    pair(
+        integer_list<int, 1, 3, 5, 7>,
+        integer_list<int, 2, 4, 6>
+    )
+);
+//! [ints]
 
-    //! [types]
-    BOOST_HANA_STATIC_ASSERT(
-        partition(trait<std::is_floating_point>, type_list<void, int, float, char, double>)
-        ==
-        pair(
-            type_list<float, double>,
-            type_list<void, int, char>
-        )
-    );
-    //! [types]
-}
+//! [types]
+BOOST_HANA_CONSTANT_ASSERT(
+    partition(trait<std::is_floating_point>, type_list<void, int, float, char, double>)
+    ==
+    pair(
+        type_list<float, double>,
+        type_list<void, int, char>
+    )
+);
+//! [types]
+
+int main() { (void)odd; }
diff --git a/example/list/permutations.cpp b/example/list/permutations.cpp
index d1d42a876..6496c475d 100644
--- a/example/list/permutations.cpp
+++ b/example/list/permutations.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -17,7 +17,7 @@ int main() {
         return elem(perm, permutations(xs));
     });
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         all(is_permutation_of(list('1', 2, 3.0)),
             list(
                 list('1', 2, 3.0),
diff --git a/example/list/reverse.cpp b/example/list/reverse.cpp
index 08ca50354..4e7073326 100644
--- a/example/list/reverse.cpp
+++ b/example/list/reverse.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(reverse(list(1, '2', 3.3)) == list(3.3, '2', 1));
+    BOOST_HANA_CONSTEXPR_ASSERT(reverse(list(1, '2', 3.3)) == list(3.3, '2', 1));
     //! [main]
 }
diff --git a/example/list/searchable/find.cpp b/example/list/searchable/find.cpp
index 3731edb2f..c354e33b7 100644
--- a/example/list/searchable/find.cpp
+++ b/example/list/searchable/find.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
@@ -15,7 +15,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(find(trait_<std::is_integral>, list(1.0, 2, '3')) == just(2));
-    BOOST_HANA_STATIC_ASSERT(find(trait_<std::is_class>, list(1.0, 2, '3')) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(find(trait_<std::is_integral>, list(1.0, 2, '3')) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(find(trait_<std::is_class>, list(1.0, 2, '3')) == nothing);
     //! [main]
 }
diff --git a/example/list/snoc.cpp b/example/list/snoc.cpp
index 1a00cd7f4..4c6066e66 100644
--- a/example/list/snoc.cpp
+++ b/example/list/snoc.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(snoc(list(), 1) == list(1));
-    BOOST_HANA_STATIC_ASSERT(snoc(list(1, '2'), 3.3) == list(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(snoc(snoc(snoc(list(), 1), '2'), 3.3) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(), 1) == list(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(1, '2'), 3.3) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(snoc(snoc(list(), 1), '2'), 3.3) == list(1, '2', 3.3));
     //! [main]
 }
diff --git a/example/list/sort.cpp b/example/list/sort.cpp
index 53fc8578f..54f73b2e6 100644
--- a/example/list/sort.cpp
+++ b/example/list/sort.cpp
@@ -4,17 +4,17 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 using namespace literals;
 
 
-int main() {
-    //! [main]
-    BOOST_HANA_STATIC_ASSERT(
-        sort(list(1_c, -2_c, 3_c, 0_c)) == list(-2_c, 0_c, 1_c, 3_c)
-    );
-    //! [main]
-}
+//! [main]
+BOOST_HANA_CONSTANT_ASSERT(
+    sort(list(1_c, -2_c, 3_c, 0_c)) == list(-2_c, 0_c, 1_c, 3_c)
+);
+//! [main]
+
+int main() { }
diff --git a/example/list/sort_by.cpp b/example/list/sort_by.cpp
index 62c0ff678..7335d940b 100644
--- a/example/list/sort_by.cpp
+++ b/example/list/sort_by.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -12,10 +12,10 @@ using namespace boost::hana;
 using namespace literals;
 
 
-int main() {
-    //! [main]
-    BOOST_HANA_STATIC_ASSERT(
-        sort_by(_>_, list(1_c, -2_c, 3_c, 0_c)) == list(3_c, 1_c, 0_c, -2_c)
-    );
-    //! [main]
-}
+//! [main]
+BOOST_HANA_CONSTANT_ASSERT(
+    sort_by(_>_, list(1_c, -2_c, 3_c, 0_c)) == list(3_c, 1_c, 0_c, -2_c)
+);
+//! [main]
+
+int main() { }
diff --git a/example/list/take.cpp b/example/list/take.cpp
index a837bd311..68abbad38 100644
--- a/example/list/take.cpp
+++ b/example/list/take.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -13,10 +13,10 @@ using namespace literals;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(take(0_c, list(1, '2', 3.3)) == list());
-    BOOST_HANA_STATIC_ASSERT(take(1_c, list(1, '2', 3.3)) == list(1));
-    BOOST_HANA_STATIC_ASSERT(take(2_c, list(1, '2', 3.3)) == list(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(take(3_c, list(1, '2', 3.3)) == list(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(take(4_c, list(1, '2', 3.3)) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTANT_ASSERT(take(0_c, list(1, '2', 3.3)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(take(1_c, list(1, '2', 3.3)) == list(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(2_c, list(1, '2', 3.3)) == list(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(3_c, list(1, '2', 3.3)) == list(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(4_c, list(1, '2', 3.3)) == list(1, '2', 3.3));
     //! [main]
 }
diff --git a/example/list/take_until.cpp b/example/list/take_until.cpp
index d1cbcac09..7456eb719 100644
--- a/example/list/take_until.cpp
+++ b/example/list/take_until.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integer_list.hpp>
@@ -15,7 +15,7 @@ using namespace literals;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         take_until(_ < 2_c, integer_list<int, 3, 2, 1, 0>) == integer_list<int, 3, 2>
     );
     //! [main]
diff --git a/example/list/take_while.cpp b/example/list/take_while.cpp
index 90d4c6d0d..50db5d672 100644
--- a/example/list/take_while.cpp
+++ b/example/list/take_while.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
@@ -14,7 +14,7 @@ using namespace literals;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         take_while(_ < 2_c, integer_list<int, 0, 1, 2, 3>) == integer_list<int, 0, 1>
     );
     //! [main]
diff --git a/example/list/traversable/traverse.cpp b/example/list/traversable/traverse.cpp
index 260349fc9..5a4394936 100644
--- a/example/list/traversable/traverse.cpp
+++ b/example/list/traversable/traverse.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
@@ -20,13 +20,13 @@ int main() {
         );
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         traverse<Maybe>(half, list(int_<2>, int_<4>, int_<6>))
         ==
         just(list(int_<1>, int_<2>, int_<3>))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         traverse<Maybe>(half, list(int_<2>, int_<3>, int_<6>))
         ==
         nothing
diff --git a/example/list/unfoldl.cpp b/example/list/unfoldl.cpp
index 9af73cc22..347dd0543 100644
--- a/example/list/unfoldl.cpp
+++ b/example/list/unfoldl.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
@@ -19,7 +19,7 @@ int main() {
         return if_(x == int_<0>, nothing, just(pair(x - int_<1>, x)));
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         unfoldl<IntegerList>(f, int_<10>) == integer_list<int, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10>
     );
     //! [main]
diff --git a/example/list/unfoldr.cpp b/example/list/unfoldr.cpp
index 0a07bb406..936d3ff59 100644
--- a/example/list/unfoldr.cpp
+++ b/example/list/unfoldr.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integer_list.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
@@ -19,7 +19,7 @@ int main() {
         return if_(x == int_<0>, nothing, just(pair(x, x - int_<1>)));
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         unfoldr<IntegerList>(f, int_<10>) == integer_list<int, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1>
     );
     //! [main]
diff --git a/example/list/unzip.cpp b/example/list/unzip.cpp
index 651263647..cdcc2eb89 100644
--- a/example/list/unzip.cpp
+++ b/example/list/unzip.cpp
@@ -4,20 +4,20 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         unzip(list(list(1, '2', 3.3), list('4', 5.5, 6)))
         ==
         list(list(1, '4'), list('2', 5.5), list(3.3, 6))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         unzip(list(list(1, '2', 3.3), list('4', 5.5, 6, "ignored")))
         ==
         list(list(1, '4'), list('2', 5.5), list(3.3, 6))
diff --git a/example/list/zip.cpp b/example/list/zip.cpp
index 0207d6959..29c1e2843 100644
--- a/example/list/zip.cpp
+++ b/example/list/zip.cpp
@@ -4,20 +4,20 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         zip(list(1, 'a'), list(2, 3.3))
         ==
         list(list(1, 2), list('a', 3.3))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         zip(list(1, 'a'), list(2, 3.3), list(3, 'c', "ignored"))
         ==
         list(list(1, 2, 3), list('a', 3.3, 'c'))
diff --git a/example/list/zip_with.cpp b/example/list/zip_with.cpp
index 0ace2bc3c..bdd987ecd 100644
--- a/example/list/zip_with.cpp
+++ b/example/list/zip_with.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -12,7 +12,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         zip_with(_ * _, list(1, 2, 3, 4), list(5, 6, 7, 8, "ignored"))
         ==
         list(5, 12, 21, 32)
diff --git a/example/logical/and.cpp b/example/logical/and.cpp
index f58df952b..a2ba10785 100644
--- a/example/logical/and.cpp
+++ b/example/logical/and.cpp
@@ -5,14 +5,14 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(and_(true_, true_, true_, true_));
-    BOOST_HANA_STATIC_ASSERT(!and_(true_, false, true_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(and_(true_, true_, true_, true_));
+    BOOST_HANA_CONSTEXPR_ASSERT(!and_(true_, false, true_, true_));
     //! [main]
 
     // Not supported right now.
diff --git a/example/logical/eval_if.cpp b/example/logical/eval_if.cpp
index 86716944e..df254e044 100644
--- a/example/logical/eval_if.cpp
+++ b/example/logical/eval_if.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/type.hpp>
@@ -23,10 +23,10 @@ int main() {
         );
     };
 
-    BOOST_HANA_STATIC_ASSERT(safe_make_unsigned(type<void>) == type<void>);
-    BOOST_HANA_STATIC_ASSERT(safe_make_unsigned(type<int>) == type<unsigned int>);
+    BOOST_HANA_CONSTANT_ASSERT(safe_make_unsigned(type<void>) == type<void>);
+    BOOST_HANA_CONSTANT_ASSERT(safe_make_unsigned(type<int>) == type<unsigned int>);
     //! [heterogeneous]
-
+    (void)safe_make_unsigned;
 
     //! [homogeneous]
     BOOST_HANA_CONSTEXPR_LAMBDA auto safe_divide = [](auto x, auto y) {
@@ -36,7 +36,7 @@ int main() {
         );
     };
 
-    BOOST_HANA_STATIC_ASSERT(safe_divide(6, 3) == 2);
-    BOOST_HANA_STATIC_ASSERT(safe_divide(6, 0) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(safe_divide(6, 3) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(safe_divide(6, 0) == 0);
     //! [homogeneous]
 }
diff --git a/example/logical/if.cpp b/example/logical/if.cpp
index 8d0d64504..03409dcd8 100644
--- a/example/logical/if.cpp
+++ b/example/logical/if.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -13,10 +13,10 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(if_(true, 1, 2) == 1);
-    BOOST_HANA_STATIC_ASSERT(if_(false, 1, 2) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(if_(true, 1, 2) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(if_(false, 1, 2) == 2);
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         if_(true_,
             std::make_tuple('t', 'r', 'u', 'e'),
             std::make_tuple('f', 'a', 'l', 's', 'e')
diff --git a/example/logical/not.cpp b/example/logical/not.cpp
index c117a506d..403efac73 100644
--- a/example/logical/not.cpp
+++ b/example/logical/not.cpp
@@ -5,13 +5,13 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(not_(true_) == false_);
-    BOOST_HANA_STATIC_ASSERT(not_(false) == true);
+    BOOST_HANA_CONSTANT_ASSERT(not_(true_) == false_);
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(false) == true);
     //! [main]
 }
diff --git a/example/logical/or.cpp b/example/logical/or.cpp
index c20e7e371..a8e2351b9 100644
--- a/example/logical/or.cpp
+++ b/example/logical/or.cpp
@@ -5,14 +5,14 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(or_(false_, false_, true_));
-    BOOST_HANA_STATIC_ASSERT(!or_(false_, false_, false_));
+    BOOST_HANA_CONSTANT_ASSERT(or_(false_, false_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(!or_(false_, false_, false_));
     //! [main]
 
     // Not supported right now.
diff --git a/example/map/searchable.cpp b/example/map/searchable.cpp
index 550b061df..6ef5e1dbf 100644
--- a/example/map/searchable.cpp
+++ b/example/map/searchable.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/maybe.hpp>
@@ -19,9 +19,9 @@ int main() {
         pair(type<int>, 'i'),
         pair(type<float>, 'f')
     );
-    BOOST_HANA_STATIC_ASSERT(lookup(type<int>, m) == just('i'));
-    BOOST_HANA_STATIC_ASSERT(lookup(type<float>, m) == just('f'));
-    BOOST_HANA_STATIC_ASSERT(lookup(type<void>, m) == nothing);
-    BOOST_HANA_STATIC_ASSERT(lookup(int_<3>, m) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(lookup(type<int>, m) == just('i'));
+    BOOST_HANA_CONSTEXPR_ASSERT(lookup(type<float>, m) == just('f'));
+    BOOST_HANA_CONSTANT_ASSERT(lookup(type<void>, m) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(lookup(int_<3>, m) == nothing);
     //! [main]
 }
diff --git a/example/maybe/applicative.cpp b/example/maybe/applicative.cpp
index 0c23f7aa2..83145c991 100644
--- a/example/maybe/applicative.cpp
+++ b/example/maybe/applicative.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -35,12 +35,12 @@ template <char x, char op, char y>
 BOOST_HANA_CONSTEXPR_LAMBDA auto evaluate = ap(function<op>, digit<x>, digit<y>);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(evaluate<'1', '+', '2'> == just(1 + 2));
+    BOOST_HANA_CONSTEXPR_ASSERT(evaluate<'1', '+', '2'> == just(1 + 2));
 
-    BOOST_HANA_STATIC_ASSERT(evaluate<'?', '+', '2'> == nothing);
-    BOOST_HANA_STATIC_ASSERT(evaluate<'1', '?', '2'> == nothing);
-    BOOST_HANA_STATIC_ASSERT(evaluate<'1', '+', '?'> == nothing);
-    BOOST_HANA_STATIC_ASSERT(evaluate<'?', '?', '?'> == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(evaluate<'?', '+', '2'> == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(evaluate<'1', '?', '2'> == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(evaluate<'1', '+', '?'> == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(evaluate<'?', '?', '?'> == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(lift<Maybe>(123) == just(123));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<Maybe>(123) == just(123));
 }
diff --git a/example/maybe/applicative_simple.cpp b/example/maybe/applicative_simple.cpp
index 4cd5c958c..c673b78f0 100644
--- a/example/maybe/applicative_simple.cpp
+++ b/example/maybe/applicative_simple.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -16,9 +16,9 @@ int main() {
         return x + 1; // next letter
     };
 
-    BOOST_HANA_STATIC_ASSERT(ap(just(f), just('x')) == just(f('x')));
-    BOOST_HANA_STATIC_ASSERT(ap(nothing, just('x')) == nothing);
-    BOOST_HANA_STATIC_ASSERT(ap(just(f), nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(ap(nothing, nothing) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(just(f), just('x')) == just(f('x')));
+    BOOST_HANA_CONSTANT_ASSERT(ap(nothing, just('x')) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(ap(just(f), nothing) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(ap(nothing, nothing) == nothing);
     //! [main]
 }
diff --git a/example/maybe/comparable.cpp b/example/maybe/comparable.cpp
index e60690aaf..32c7c5c7b 100644
--- a/example/maybe/comparable.cpp
+++ b/example/maybe/comparable.cpp
@@ -4,16 +4,16 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(nothing == nothing);
-    BOOST_HANA_STATIC_ASSERT(just('x') == just('x'));
-    BOOST_HANA_STATIC_ASSERT(just('x') != just(3));
-    BOOST_HANA_STATIC_ASSERT(just('x') != nothing);
+    BOOST_HANA_CONSTANT_ASSERT(nothing == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(just('x') == just('x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(just('x') != just(3));
+    BOOST_HANA_CONSTANT_ASSERT(just('x') != nothing);
     //! [main]
 }
diff --git a/example/maybe/foldable.cpp b/example/maybe/foldable.cpp
index 5b775775c..7fdd10b63 100644
--- a/example/maybe/foldable.cpp
+++ b/example/maybe/foldable.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -16,7 +16,7 @@ int main() {
         return x + y;
     };
 
-    BOOST_HANA_STATIC_ASSERT(foldr(plus, 1, nothing) == 1);
-    BOOST_HANA_STATIC_ASSERT(foldr(plus, 1, just(4)) == 5);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(plus, 1, nothing) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(plus, 1, just(4)) == 5);
     //! [main]
 }
diff --git a/example/maybe/from_just.cpp b/example/maybe/from_just.cpp
index 02bac4f86..53ceb64ae 100644
--- a/example/maybe/from_just.cpp
+++ b/example/maybe/from_just.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(from_just(just('x')) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(from_just(just('x')) == 'x');
     // from_just(nothing); // compile-time static assertion
     // ! [main]
 }
diff --git a/example/maybe/from_maybe.cpp b/example/maybe/from_maybe.cpp
index f250c7a15..04e52d689 100644
--- a/example/maybe/from_maybe.cpp
+++ b/example/maybe/from_maybe.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(from_maybe('x', just(1)) == 1);
-    BOOST_HANA_STATIC_ASSERT(from_maybe('x', nothing) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(from_maybe('x', just(1)) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(from_maybe('x', nothing) == 'x');
     //! [main]
 }
diff --git a/example/maybe/functor.cpp b/example/maybe/functor.cpp
index 8525e4332..758bb8b87 100644
--- a/example/maybe/functor.cpp
+++ b/example/maybe/functor.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -13,7 +13,7 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto inc = [](auto x) { return x + 1; };
-    BOOST_HANA_STATIC_ASSERT(fmap(inc, nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(fmap(inc, just(1)) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(inc, nothing) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(inc, just(1)) == just(2));
     //! [main]
 }
diff --git a/example/maybe/is_just.cpp b/example/maybe/is_just.cpp
index eb9e9c8c0..18b060830 100644
--- a/example/maybe/is_just.cpp
+++ b/example/maybe/is_just.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT( is_just(just('x')));
-    BOOST_HANA_STATIC_ASSERT( is_just(just(nothing)));
-    BOOST_HANA_STATIC_ASSERT(!is_just(nothing));
+    BOOST_HANA_CONSTANT_ASSERT( is_just(just('x')));
+    BOOST_HANA_CONSTANT_ASSERT( is_just(just(nothing)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_just(nothing));
     //! [main]
 }
diff --git a/example/maybe/is_nothing.cpp b/example/maybe/is_nothing.cpp
index 3483e2bd2..d824811f2 100644
--- a/example/maybe/is_nothing.cpp
+++ b/example/maybe/is_nothing.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT( is_nothing(nothing));
-    BOOST_HANA_STATIC_ASSERT(!is_nothing(just('x')));
-    BOOST_HANA_STATIC_ASSERT(!is_nothing(just(nothing)));
+    BOOST_HANA_CONSTANT_ASSERT( is_nothing(nothing));
+    BOOST_HANA_CONSTANT_ASSERT(!is_nothing(just('x')));
+    BOOST_HANA_CONSTANT_ASSERT(!is_nothing(just(nothing)));
     //! [main]
 }
diff --git a/example/maybe/maybe.cpp b/example/maybe/maybe.cpp
index ec2225700..50b801bc1 100644
--- a/example/maybe/maybe.cpp
+++ b/example/maybe/maybe.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -13,7 +13,7 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto inc = [](auto x) { return x + 1; };
-    BOOST_HANA_STATIC_ASSERT(maybe('x', inc, just(1)) == 2);
-    BOOST_HANA_STATIC_ASSERT(maybe('x', inc, nothing) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(maybe('x', inc, just(1)) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(maybe('x', inc, nothing) == 'x');
     //! [main]
 }
diff --git a/example/maybe/monad.cpp b/example/maybe/monad.cpp
index 222a9faed..bd8c40069 100644
--- a/example/maybe/monad.cpp
+++ b/example/maybe/monad.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -16,9 +16,9 @@ int main() {
         return just(x + 1);
     };
 
-    BOOST_HANA_STATIC_ASSERT(bind(just(1), inc) == just(2));
-    BOOST_HANA_STATIC_ASSERT(bind(nothing, inc) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(bind(just(1), inc) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(bind(nothing, inc) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(flatten(just(just(2))) == just(2));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(just(just(2))) == just(2));
     //! [main]
 }
diff --git a/example/maybe/only_when.cpp b/example/maybe/only_when.cpp
index fd0147ca0..5f6c32a97 100644
--- a/example/maybe/only_when.cpp
+++ b/example/maybe/only_when.cpp
@@ -4,24 +4,24 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
 
-int main() {
-    //! [main]
-    BOOST_HANA_CONSTEXPR_LAMBDA auto even = [](auto x) {
-        return x % int_<2> == int_<0>;
-    };
+//! [main]
+BOOST_HANA_CONSTEXPR_LAMBDA auto even = [](auto x) {
+    return x % int_<2> == int_<0>;
+};
 
-    BOOST_HANA_CONSTEXPR_LAMBDA auto half = [](auto x) {
-        return x / int_<2>;
-    };
+BOOST_HANA_CONSTEXPR_LAMBDA auto half = [](auto x) {
+    return x / int_<2>;
+};
 
-    BOOST_HANA_STATIC_ASSERT(only_when(even, half, int_<4>) == just(int_<2>));
-    BOOST_HANA_STATIC_ASSERT(only_when(even, half, int_<3>) == nothing);
-    //! [main]
-}
+BOOST_HANA_CONSTANT_ASSERT(only_when(even, half, int_<4>) == just(int_<2>));
+BOOST_HANA_CONSTANT_ASSERT(only_when(even, half, int_<3>) == nothing);
+//! [main]
+
+int main() { (void)even; (void)half; }
diff --git a/example/maybe/searchable.cpp b/example/maybe/searchable.cpp
index 7642fd2e4..46f407cd7 100644
--- a/example/maybe/searchable.cpp
+++ b/example/maybe/searchable.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -17,11 +17,11 @@ int main() {
         return x % int_<2> != int_<0>;
     };
 
-    BOOST_HANA_STATIC_ASSERT(find(odd, just(int_<3>)) == just(int_<3>));
-    BOOST_HANA_STATIC_ASSERT(find(odd, just(int_<2>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(find(odd, nothing) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(odd, just(int_<3>)) == just(int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(find(odd, just(int_<2>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(odd, nothing) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(all(odd, just(int_<3>)));
-    BOOST_HANA_STATIC_ASSERT(all(odd, nothing));
+    BOOST_HANA_CONSTANT_ASSERT(all(odd, just(int_<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(all(odd, nothing));
     //! [main]
 }
diff --git a/example/maybe/traversable.cpp b/example/maybe/traversable.cpp
index 2ea28c30d..a4f22a8a5 100644
--- a/example/maybe/traversable.cpp
+++ b/example/maybe/traversable.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -17,7 +17,7 @@ int main() {
         return list(x, x, x);
     };
 
-    BOOST_HANA_STATIC_ASSERT(traverse<List>(replicate3, just(1)) == list(just(1), just(1), just(1)));
-    BOOST_HANA_STATIC_ASSERT(traverse<List>(replicate3, nothing) == list(nothing));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<List>(replicate3, just(1)) == list(just(1), just(1), just(1)));
+    BOOST_HANA_CONSTANT_ASSERT(traverse<List>(replicate3, nothing) == list(nothing));
     //! [main]
 }
diff --git a/example/monad/bind.cpp b/example/monad/bind.cpp
index 41d784e90..0e871c956 100644
--- a/example/monad/bind.cpp
+++ b/example/monad/bind.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 using namespace boost::hana;
@@ -43,11 +43,11 @@ int main() {
     Person john{30};
 
     // Can't dereference a non-pointer.
-    BOOST_HANA_STATIC_ASSERT(f(john) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(f(john) == nothing);
 
     // `int` has no member named `age`.
-    BOOST_HANA_STATIC_ASSERT(f(1) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(f(1) == nothing);
 
     // All is good.
-    BOOST_HANA_STATIC_ASSERT(f(&john) == just(30u));
+    BOOST_HANA_CONSTEXPR_ASSERT(f(&john) == just(30u));
 }
diff --git a/example/monad/flatten.cpp b/example/monad/flatten.cpp
index 164c0d104..e4ef79db4 100644
--- a/example/monad/flatten.cpp
+++ b/example/monad/flatten.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -12,14 +12,14 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         flatten(list(list(1, 2, 3), list(4, 5), list(6, 7, 8, 9)))
         ==
         list(1, 2, 3, 4, 5, 6, 7, 8, 9)
     );
 
-    BOOST_HANA_STATIC_ASSERT(flatten(nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(flatten(just(just(1))) == just(1));
-    BOOST_HANA_STATIC_ASSERT(flatten(just(nothing)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(flatten(nothing) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(just(just(1))) == just(1));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(just(nothing)) == nothing);
     //! [main]
 }
diff --git a/example/monad/then.cpp b/example/monad/then.cpp
index 7a46fca9c..925e64ae0 100644
--- a/example/monad/then.cpp
+++ b/example/monad/then.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -13,7 +13,7 @@ struct undefined { };
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         then(list(undefined{}, undefined{}), list(1, 2, 3)) == list(
             1, 2, 3,
             1, 2, 3
diff --git a/example/orderable/greater.cpp b/example/orderable/greater.cpp
index ab9853a09..39474b299 100644
--- a/example/orderable/greater.cpp
+++ b/example/orderable/greater.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(greater(4, 1));
-    BOOST_HANA_STATIC_ASSERT(!greater(int_<1>, int_<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater(4, 1));
+    BOOST_HANA_CONSTANT_ASSERT(!greater(int_<1>, int_<3>));
     //! [main]
 }
diff --git a/example/orderable/greater_equal.cpp b/example/orderable/greater_equal.cpp
index 79b085407..420f82b82 100644
--- a/example/orderable/greater_equal.cpp
+++ b/example/orderable/greater_equal.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(greater_equal(4, 1));
-    BOOST_HANA_STATIC_ASSERT(greater_equal(1, 1));
-    BOOST_HANA_STATIC_ASSERT(!greater_equal(int_<1>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater_equal(4, 1));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater_equal(1, 1));
+    BOOST_HANA_CONSTANT_ASSERT(!greater_equal(int_<1>, int_<2>));
     //! [main]
 }
diff --git a/example/orderable/less.cpp b/example/orderable/less.cpp
index 98c6ba442..85750ff3b 100644
--- a/example/orderable/less.cpp
+++ b/example/orderable/less.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(less(1, 4));
-    BOOST_HANA_STATIC_ASSERT(!less(int_<3>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(1, 4));
+    BOOST_HANA_CONSTANT_ASSERT(!less(int_<3>, int_<2>));
     //! [main]
 }
diff --git a/example/orderable/less_equal.cpp b/example/orderable/less_equal.cpp
index 094dd06ae..d05681742 100644
--- a/example/orderable/less_equal.cpp
+++ b/example/orderable/less_equal.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(less_equal(1, 4));
-    BOOST_HANA_STATIC_ASSERT(less_equal(1, 1));
-    BOOST_HANA_STATIC_ASSERT(!less_equal(int_<3>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_equal(1, 4));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_equal(1, 1));
+    BOOST_HANA_CONSTANT_ASSERT(!less_equal(int_<3>, int_<2>));
     //! [main]
 }
diff --git a/example/orderable/max.cpp b/example/orderable/max.cpp
index 5a8eb1b6a..d76078dac 100644
--- a/example/orderable/max.cpp
+++ b/example/orderable/max.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(max(1, 4) == 4);
-    BOOST_HANA_STATIC_ASSERT(max(int_<7>, int_<5>) == int_<7>);
+    BOOST_HANA_CONSTEXPR_ASSERT(max(1, 4) == 4);
+    BOOST_HANA_CONSTANT_ASSERT(max(int_<7>, int_<5>) == int_<7>);
     //! [main]
 }
diff --git a/example/orderable/min.cpp b/example/orderable/min.cpp
index ef99c447f..a149ff238 100644
--- a/example/orderable/min.cpp
+++ b/example/orderable/min.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(min(1, 4) == 1);
-    BOOST_HANA_STATIC_ASSERT(min(int_<7>, int_<5>) == int_<5>);
+    BOOST_HANA_CONSTEXPR_ASSERT(min(1, 4) == 1);
+    BOOST_HANA_CONSTANT_ASSERT(min(int_<7>, int_<5>) == int_<5>);
     //! [main]
 }
diff --git a/example/orderable/ordering.cpp b/example/orderable/ordering.cpp
index 59548a81d..bfdf7d207 100644
--- a/example/orderable/ordering.cpp
+++ b/example/orderable/ordering.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
@@ -19,7 +19,7 @@ int main() {
         type<char[2]>,
         type<char[15]>
     ));
-    BOOST_HANA_STATIC_ASSERT(sorted == list(
+    BOOST_HANA_CONSTANT_ASSERT(sorted == list(
         type<char[1]>,
         type<char[2]>,
         type<char[3]>,
diff --git a/example/pair/pair.cpp b/example/pair/pair.cpp
index b5ec54201..988602d9d 100644
--- a/example/pair/pair.cpp
+++ b/example/pair/pair.cpp
@@ -4,14 +4,14 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(first(pair(1, 'x')) == 1);
-    BOOST_HANA_STATIC_ASSERT(second(pair(1, 'x')) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(first(pair(1, 'x')) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(pair(1, 'x')) == 'x');
     //! [main]
 }
diff --git a/example/pair/product.cpp b/example/pair/product.cpp
index e963a393d..dbf630738 100644
--- a/example/pair/product.cpp
+++ b/example/pair/product.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(make_product<Pair>(1, 'x') == pair(1, 'x'));
-    BOOST_HANA_STATIC_ASSERT(first(pair(1, 'x')) == 1);
-    BOOST_HANA_STATIC_ASSERT(second(pair(1, 'x')) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(make_product<Pair>(1, 'x') == pair(1, 'x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(first(pair(1, 'x')) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(pair(1, 'x')) == 'x');
     //! [main]
 }
diff --git a/example/product/comparable.cpp b/example/product/comparable.cpp
index b9de097b6..d66884572 100644
--- a/example/product/comparable.cpp
+++ b/example/product/comparable.cpp
@@ -4,17 +4,16 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 
 #include <string>
-#include <cassert>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    assert(pair(1, std::string{"234"}) == pair(1, "234"));
-    BOOST_HANA_STATIC_ASSERT(pair('x', 2) != pair('y', 2));
+    BOOST_HANA_RUNTIME_ASSERT(pair(1, std::string{"234"}) == pair(1, "234"));
+    BOOST_HANA_CONSTEXPR_ASSERT(pair('x', 2) != pair('y', 2));
     //! [main]
 }
diff --git a/example/product/first.cpp b/example/product/first.cpp
index 076dfbc7c..4bf93d8ce 100644
--- a/example/product/first.cpp
+++ b/example/product/first.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(first(pair(1, 'x')) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(first(pair(1, 'x')) == 1);
     //! [main]
 }
diff --git a/example/product/make_product.cpp b/example/product/make_product.cpp
index 9a4a6372a..315706f05 100644
--- a/example/product/make_product.cpp
+++ b/example/product/make_product.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(make_product<Pair>(1, 'x') == pair(1, 'x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(make_product<Pair>(1, 'x') == pair(1, 'x'));
     //! [main]
 }
diff --git a/example/product/second.cpp b/example/product/second.cpp
index e94148c8d..581772e12 100644
--- a/example/product/second.cpp
+++ b/example/product/second.cpp
@@ -4,13 +4,13 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(second(pair(1, 'x')) == 'x');
+    BOOST_HANA_CONSTEXPR_ASSERT(second(pair(1, 'x')) == 'x');
     //! [main]
 }
diff --git a/example/range/iterable.cpp b/example/range/iterable.cpp
index 0ba8929cc..88ea2229c 100644
--- a/example/range/iterable.cpp
+++ b/example/range/iterable.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/range.hpp>
 using namespace boost::hana;
@@ -14,9 +14,9 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto r = range(int_<0>, int_<1000>);
-    BOOST_HANA_STATIC_ASSERT(head(r) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(last(r) == int_<999>);
-    BOOST_HANA_STATIC_ASSERT(!is_empty(r));
-    BOOST_HANA_STATIC_ASSERT(is_empty(range(int_<3>, int_<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(head(r) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(last(r) == int_<999>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(r));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(range(int_<3>, int_<3>)));
     //! [main]
 }
diff --git a/example/range/range.cpp b/example/range/range.cpp
index 7459f48e8..1c1fca9ab 100644
--- a/example/range/range.cpp
+++ b/example/range/range.cpp
@@ -4,17 +4,17 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/range.hpp>
 using namespace boost::hana;
 using namespace literals;
 
 
-int main() {
-    //! [main]
-    BOOST_HANA_STATIC_ASSERT(head(range(0_c, 5_c)) == 0_c);
-    BOOST_HANA_STATIC_ASSERT(last(range(0_c, 5_c)) == 4_c);
-    BOOST_HANA_STATIC_ASSERT(tail(range(0_c, 5_c)) == range(1_c, 5_c));
-    //! [main]
-}
+//! [main]
+BOOST_HANA_CONSTANT_ASSERT(head(range(0_c, 5_c)) == 0_c);
+BOOST_HANA_CONSTANT_ASSERT(last(range(0_c, 5_c)) == 4_c);
+BOOST_HANA_CONSTANT_ASSERT(tail(range(0_c, 5_c)) == range(1_c, 5_c));
+//! [main]
+
+int main() { }
diff --git a/example/searchable/all.cpp b/example/searchable/all.cpp
index 9b9276636..648741e40 100644
--- a/example/searchable/all.cpp
+++ b/example/searchable/all.cpp
@@ -4,8 +4,9 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -21,13 +22,13 @@ int main() {
         return x % 2_c != 0_c;
     };
 
-    BOOST_HANA_STATIC_ASSERT(all(odd, list(1, 3)));
-    BOOST_HANA_STATIC_ASSERT(!all(odd, list(3_c, 4_c)));
+    BOOST_HANA_CONSTEXPR_ASSERT(all(odd, list(1, 3)));
+    BOOST_HANA_CONSTANT_ASSERT(!all(odd, list(3_c, 4_c)));
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         !all(trait<std::is_void>, list(type<void>, type<char&>))
     );
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         all(trait<std::is_integral>, list(type<int>, type<char>))
     );
     //! [main]
diff --git a/example/searchable/all_of.cpp b/example/searchable/all_of.cpp
index 3fedc5b73..9a30e40f0 100644
--- a/example/searchable/all_of.cpp
+++ b/example/searchable/all_of.cpp
@@ -5,14 +5,14 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(all_of(list(true_, true, true_)));
-    BOOST_HANA_STATIC_ASSERT(!all_of(list(true_, false_, true_)));
+    BOOST_HANA_CONSTEXPR_ASSERT(all_of(list(true_, true, true_)));
+    BOOST_HANA_CONSTANT_ASSERT(!all_of(list(true, false_, true_)));
     //! [main]
 }
diff --git a/example/searchable/any.cpp b/example/searchable/any.cpp
index 34f840155..1e546ee74 100644
--- a/example/searchable/any.cpp
+++ b/example/searchable/any.cpp
@@ -4,8 +4,9 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -21,13 +22,13 @@ int main() {
         return x % 2_c != 0_c;
     };
 
-    BOOST_HANA_STATIC_ASSERT(any(odd, list(1, 2)));
-    BOOST_HANA_STATIC_ASSERT(!any(odd, list(2_c, 4_c)));
+    BOOST_HANA_CONSTEXPR_ASSERT(any(odd, list(1, 2)));
+    BOOST_HANA_CONSTANT_ASSERT(!any(odd, list(2_c, 4_c)));
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         any(trait<std::is_void>, list(type<void>, type<char&>))
     );
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         !any(trait<std::is_integral>, list(type<void>, type<char&>))
     );
     //! [main]
diff --git a/example/searchable/any_of.cpp b/example/searchable/any_of.cpp
index e9a27bcfd..16a5b638b 100644
--- a/example/searchable/any_of.cpp
+++ b/example/searchable/any_of.cpp
@@ -5,14 +5,15 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(any_of(list(false, false_, true_)));
-    BOOST_HANA_STATIC_ASSERT(!any_of(list(false, false_, false_)));
+    BOOST_HANA_CONSTANT_ASSERT(any_of(list(false, false_, true_)));
+    BOOST_HANA_CONSTEXPR_ASSERT(any_of(list(false, false_, true)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any_of(list(false, false_, false_)));
     //! [main]
 }
diff --git a/example/searchable/elem.cpp b/example/searchable/elem.cpp
index 57abf34af..31bc1e7ed 100644
--- a/example/searchable/elem.cpp
+++ b/example/searchable/elem.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/set.hpp>
@@ -14,7 +14,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(elem(int_<3>, list(2, int_<2>, int_<3>, 'x')));
-    BOOST_HANA_STATIC_ASSERT(elem(type<int>, set(1, '2', type<int>, "foobar")));
+    BOOST_HANA_CONSTANT_ASSERT(elem(int_<3>, list(2, int_<2>, int_<3>, 'x')));
+    BOOST_HANA_CONSTANT_ASSERT(elem(type<int>, set(1, '2', type<int>, "foobar")));
     //! [main]
 }
diff --git a/example/searchable/find.cpp b/example/searchable/find.cpp
index 88a83f515..147dc7171 100644
--- a/example/searchable/find.cpp
+++ b/example/searchable/find.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -18,11 +18,11 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(find(trait_<std::is_integral>, list(1.0, 2, '3')) == just(2));
-    BOOST_HANA_STATIC_ASSERT(find(trait_<std::is_class>, list(1.0, 2, '3')) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(find(trait_<std::is_integral>, list(1.0, 2, '3')) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(find(trait_<std::is_class>, list(1.0, 2, '3')) == nothing);
 
     constexpr auto types = type_list<char, int, unsigned, long, unsigned long>;
-    BOOST_HANA_STATIC_ASSERT(find(_ == type<unsigned>, types) == just(type<unsigned>));
-    BOOST_HANA_STATIC_ASSERT(find(_ == type<void>, types) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(_ == type<unsigned>, types) == just(type<unsigned>));
+    BOOST_HANA_CONSTANT_ASSERT(find(_ == type<void>, types) == nothing);
     //! [main]
 }
diff --git a/example/searchable/lookup.cpp b/example/searchable/lookup.cpp
index fd6ccca19..433fd132c 100644
--- a/example/searchable/lookup.cpp
+++ b/example/searchable/lookup.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/map.hpp>
@@ -16,10 +16,10 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(lookup(type<int>, list(int_<1>, type<int>, '3')) == just(type<int>));
-    BOOST_HANA_STATIC_ASSERT(lookup(type<void>, list(int_<1>, type<int>, '3')) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(lookup(type<int>, list(int_<1>, type<int>, '3')) == just(type<int>));
+    BOOST_HANA_CONSTANT_ASSERT(lookup(type<void>, list(int_<1>, type<int>, '3')) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(lookup(type<float>, map(
+    BOOST_HANA_CONSTEXPR_ASSERT(lookup(type<float>, map(
         pair(1, 'x'),
         pair(type<float>, 3.3),
         pair(type<char>, type<int>)
diff --git a/example/searchable/none.cpp b/example/searchable/none.cpp
index f77fb542c..06bb9a56b 100644
--- a/example/searchable/none.cpp
+++ b/example/searchable/none.cpp
@@ -4,8 +4,9 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -21,13 +22,13 @@ int main() {
         return x % 2_c != 0_c;
     };
 
-    BOOST_HANA_STATIC_ASSERT(none(odd, list(2_c, 4_c)));
-    BOOST_HANA_STATIC_ASSERT(!none(odd, list(1, 2)));
+    BOOST_HANA_CONSTANT_ASSERT(none(odd, list(2_c, 4_c)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!none(odd, list(1, 2)));
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         !none(trait<std::is_void>, list(type<void>, type<char&>))
     );
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         none(trait<std::is_integral>, list(type<void>, type<char&>))
     );
     //! [main]
diff --git a/example/searchable/none_of.cpp b/example/searchable/none_of.cpp
index b1f6da406..0a669c5f9 100644
--- a/example/searchable/none_of.cpp
+++ b/example/searchable/none_of.cpp
@@ -5,14 +5,15 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(none_of(list(false, false_, false_)));
-    BOOST_HANA_STATIC_ASSERT(!none_of(list(false, false_, true_)));
+    BOOST_HANA_CONSTEXPR_ASSERT(none_of(list(false, false_, false_)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!none_of(list(false, false_, true)));
+    BOOST_HANA_CONSTANT_ASSERT(!none_of(list(false, false_, true_)));
     //! [main]
 }
diff --git a/example/set/comparable.cpp b/example/set/comparable.cpp
index 2d75a8ea6..18b042468 100644
--- a/example/set/comparable.cpp
+++ b/example/set/comparable.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/set.hpp>
 using namespace boost::hana;
@@ -12,6 +12,6 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(set(int_<0>, int_<1>, int_<2>) == set(int_<2>, int_<1>, int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(set(int_<0>, int_<1>, int_<2>) == set(int_<2>, int_<1>, int_<0>));
     //! [main]
 }
diff --git a/example/set/searchable.cpp b/example/set/searchable.cpp
index 1b4c12ae8..f15d93812 100644
--- a/example/set/searchable.cpp
+++ b/example/set/searchable.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/set.hpp>
@@ -15,7 +15,7 @@ using namespace boost::hana;
 int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto xs = set(int_<0>, int_<1>, int_<2>);
-    BOOST_HANA_STATIC_ASSERT(lookup(int_<0>, xs) == just(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(lookup(int_<3>, xs) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(lookup(int_<0>, xs) == just(int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(lookup(int_<3>, xs) == nothing);
     //! [main]
 }
diff --git a/example/traversable/sequence.cpp b/example/traversable/sequence.cpp
index 44c927823..5bfffc2a1 100644
--- a/example/traversable/sequence.cpp
+++ b/example/traversable/sequence.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -12,16 +12,16 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         sequence<Maybe>(list(just(1), just('2'), just(3.3))) == just(list(1, '2', 3.3))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         sequence<Maybe>(list(just(1), nothing, just(3.3))) == nothing
     );
 
     // This is a generalized Cartesian product.
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         sequence<List>(list(list(1, 2, 3), list(4), list(5, 6)))
         ==
         list(
diff --git a/example/traversable/traverse.cpp b/example/traversable/traverse.cpp
index 379f70dbe..cca2e7fb0 100644
--- a/example/traversable/traverse.cpp
+++ b/example/traversable/traverse.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/maybe.hpp>
@@ -20,13 +20,13 @@ int main() {
         );
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         traverse<Maybe>(half, list(int_<2>, int_<4>, int_<6>))
         ==
         just(list(int_<1>, int_<2>, int_<3>))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         traverse<Maybe>(half, list(int_<2>, int_<3>, int_<6>))
         ==
         nothing
@@ -38,11 +38,11 @@ int main() {
         return list(x, x);
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         traverse<List>(twice, just('x')) == list(just('x'), just('x'))
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         traverse<List>(twice, nothing) == list(nothing)
     );
     //! [maybe]
diff --git a/example/tutorial/basic_concepts/constant/integral.cpp b/example/tutorial/basic_concepts/constant/integral.cpp
index f7a6be24c..4f7d719ee 100644
--- a/example/tutorial/basic_concepts/constant/integral.cpp
+++ b/example/tutorial/basic_concepts/constant/integral.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <type_traits>
@@ -37,10 +37,10 @@ auto yes = bool_<true>;
 //! [integral_shorthands]
 }
 
-int main() {
 //! [integral_operators]
-BOOST_HANA_STATIC_ASSERT(int_<1> == integral<int, 1>);
-BOOST_HANA_STATIC_ASSERT(int_<1> + long_<2> == long_<3>);
-BOOST_HANA_STATIC_ASSERT(!(bool_<true> && bool_<false>));
+BOOST_HANA_CONSTANT_ASSERT(int_<1> == integral<int, 1>);
+BOOST_HANA_CONSTANT_ASSERT(int_<1> + long_<2> == long_<3>);
+BOOST_HANA_CONSTANT_ASSERT(!(bool_<true> && bool_<false>));
 //! [integral_operators]
-}
+
+int main() { }
diff --git a/example/tutorial/organization/include_ext.cpp b/example/tutorial/organization/include_ext.cpp
index 04f24b662..0615e0b53 100644
--- a/example/tutorial/organization/include_ext.cpp
+++ b/example/tutorial/organization/include_ext.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 //! [main]
 #include <boost/hana/ext/std/tuple.hpp>
@@ -14,6 +14,6 @@ using namespace boost::hana;
 
 int main() {
     constexpr std::tuple<int, char, float> xs{1, '2', 3.0f};
-    BOOST_HANA_STATIC_ASSERT(head(xs) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(xs) == 1);
 }
 //! [main]
diff --git a/example/tutorial/organization/include_set.cpp b/example/tutorial/organization/include_set.cpp
index a38bedc5a..4806681e6 100644
--- a/example/tutorial/organization/include_set.cpp
+++ b/example/tutorial/organization/include_set.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 //! [main]
 #include <boost/hana/set.hpp>
@@ -14,6 +14,6 @@ using namespace boost::hana;
 
 int main() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto xs = set(1, 2.2, 'x');
-    BOOST_HANA_STATIC_ASSERT(elem('x', xs));
+    BOOST_HANA_CONSTEXPR_ASSERT(elem('x', xs));
 }
 //! [main]
diff --git a/example/tutorial/quickstart.cpp b/example/tutorial/quickstart.cpp
index 5ded5a2f4..8bc372068 100644
--- a/example/tutorial/quickstart.cpp
+++ b/example/tutorial/quickstart.cpp
@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <tuple>
 #include <type_traits>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 //! [includes]
 #include <boost/hana.hpp>
@@ -29,7 +29,7 @@ assert(last(xs) == "345");
 
 assert(tail(xs) == list('2', std::string{"345"}));
 
-BOOST_HANA_STATIC_ASSERT(!is_empty(xs));
+BOOST_HANA_CONSTANT_ASSERT(!is_empty(xs));
 
 for_each(xs, [](auto x) {
     std::cout << x;
@@ -54,9 +54,9 @@ auto ts = list(type<int*>, type<void>, type<char const>);
 //! [ts]
 
 //! [type_operations]
-BOOST_HANA_STATIC_ASSERT(last(ts) == type<char const>);
+BOOST_HANA_CONSTANT_ASSERT(last(ts) == type<char const>);
 
-BOOST_HANA_STATIC_ASSERT(tail(ts) == list(type<void>, type<char const>));
+BOOST_HANA_CONSTANT_ASSERT(tail(ts) == list(type<void>, type<char const>));
 //! [type_operations]
 
 //! [type_out]
diff --git a/example/type/comparable.cpp b/example/type/comparable.cpp
index 6efdb9441..b899e142e 100644
--- a/example/type/comparable.cpp
+++ b/example/type/comparable.cpp
@@ -4,16 +4,16 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
 
-int main() {
-    //! [main]
-    struct T;
-    struct U;
-    BOOST_HANA_STATIC_ASSERT(type<T> == type<T>);
-    BOOST_HANA_STATIC_ASSERT(type<T> != type<U>);
-    //! [main]
-}
+//! [main]
+struct T;
+struct U;
+BOOST_HANA_CONSTANT_ASSERT(type<T> == type<T>);
+BOOST_HANA_CONSTANT_ASSERT(type<T> != type<U>);
+//! [main]
+
+int main() { }
diff --git a/example/type/decltype.cpp b/example/type/decltype.cpp
index 82e7c0548..b95189017 100644
--- a/example/type/decltype.cpp
+++ b/example/type/decltype.cpp
@@ -4,15 +4,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
 
-int main() {
-    //! [main]
-    struct X { };
-    BOOST_HANA_STATIC_ASSERT(type<X> == decltype_(X{}));
-    BOOST_HANA_STATIC_ASSERT(type<int> == decltype_(1));
-    //! [main]
-}
+//! [main]
+struct X { };
+BOOST_HANA_CONSTANT_ASSERT(type<X> == decltype_(X{}));
+BOOST_HANA_CONSTANT_ASSERT(type<int> == decltype_(1));
+//! [main]
+
+int main() { }
diff --git a/example/type/sizeof.cpp b/example/type/sizeof.cpp
index eca9b3d49..f3a9200bc 100644
--- a/example/type/sizeof.cpp
+++ b/example/type/sizeof.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
@@ -12,7 +12,7 @@ using namespace boost::hana;
 int main() {
     //! [main]
     struct X { };
-    BOOST_HANA_STATIC_ASSERT(sizeof_(type<X>) == sizeof(X));
-    BOOST_HANA_STATIC_ASSERT(sizeof_(type<int>) == sizeof(int));
+    BOOST_HANA_CONSTEXPR_ASSERT(sizeof_(type<X>) == sizeof(X));
+    BOOST_HANA_CONSTEXPR_ASSERT(sizeof_(type<int>) == sizeof(int));
     //! [main]
 }
diff --git a/example/type/template.cpp b/example/type/template.cpp
index b26a741e6..33ecb4c4b 100644
--- a/example/type/template.cpp
+++ b/example/type/template.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <type_traits>
@@ -16,14 +16,14 @@ template <typename ...> struct f;
 struct x;
 struct y;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(template_<f>() == type<f<>>);
-    BOOST_HANA_STATIC_ASSERT(template_<f>(type<x>) == type<f<x>>);
-    BOOST_HANA_STATIC_ASSERT(template_<f>(type<x>, type<y>) == type<f<x, y>>);
+BOOST_HANA_CONSTANT_ASSERT(template_<f>() == type<f<>>);
+BOOST_HANA_CONSTANT_ASSERT(template_<f>(type<x>) == type<f<x>>);
+BOOST_HANA_CONSTANT_ASSERT(template_<f>(type<x>, type<y>) == type<f<x, y>>);
 
-    static_assert(std::is_same<
-        decltype(template_<f>)::apply<x, y>::type,
-        f<x, y>
-    >::value, "");
-}
+static_assert(std::is_same<
+    decltype(template_<f>)::apply<x, y>::type,
+    f<x, y>
+>::value, "");
 //! [main]
+
+int main() { }
diff --git a/example/type/trait.cpp b/example/type/trait.cpp
index f272ad9e1..186a6a58a 100644
--- a/example/type/trait.cpp
+++ b/example/type/trait.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/type.hpp>
@@ -16,15 +16,17 @@ using namespace boost::hana;
 
 int main() {
     //! [liftable]
-    BOOST_HANA_STATIC_ASSERT(trait<std::is_integral>(type<int>));
-    BOOST_HANA_STATIC_ASSERT(!trait<std::is_integral>(type<float>));
+    using operators::operator!; // required to negate the result of std::is_integral
+
+    BOOST_HANA_CONSTANT_ASSERT(trait<std::is_integral>(type<int>));
+    BOOST_HANA_CONSTANT_ASSERT(!trait<std::is_integral>(type<float>));
     //! [liftable]
 
     //! [nonliftable]
     BOOST_HANA_CONSTEXPR_LAMBDA auto extent = [](auto t, auto n) {
         return std::extent<typename decltype(t)::type, n()>{};
     };
-    BOOST_HANA_STATIC_ASSERT(extent(type<char>, int_<1>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(extent(type<char[1][2]>, int_<1>) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(extent(type<char>, int_<1>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(extent(type<char[1][2]>, int_<1>) == int_<2>);
     //! [nonliftable]
 }
diff --git a/example/type/trait_.cpp b/example/type/trait_.cpp
index 752794777..1f3d3e690 100644
--- a/example/type/trait_.cpp
+++ b/example/type/trait_.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/type.hpp>
 
@@ -14,8 +14,8 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(trait_<std::is_integral>(2));
-    BOOST_HANA_STATIC_ASSERT(trait_<std::is_integral>(2ll));
-    BOOST_HANA_STATIC_ASSERT(!trait_<std::is_integral>(2.2));
+    BOOST_HANA_CONSTANT_ASSERT(trait_<std::is_integral>(2));
+    BOOST_HANA_CONSTANT_ASSERT(trait_<std::is_integral>(2ll));
+    BOOST_HANA_CONSTANT_ASSERT(not_(trait_<std::is_integral>(2.2)));
     //! [main]
 }
diff --git a/example/type_list/functor/fmap.cpp b/example/type_list/functor/fmap.cpp
index ecf898ba4..95bf2666e 100644
--- a/example/type_list/functor/fmap.cpp
+++ b/example/type_list/functor/fmap.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/type.hpp>
 #include <boost/hana/type_list.hpp>
 
@@ -17,7 +17,7 @@ int main() {
     //! [main]
     BOOST_HANA_CONSTEXPR_LAMBDA auto types = type_list<void, int(), char[10]>;
     BOOST_HANA_CONSTEXPR_LAMBDA auto pointers = fmap(template_<std::add_pointer_t>, types);
-    BOOST_HANA_STATIC_ASSERT(pointers == type_list<void*, int(*)(), char(*)[10]>);
-    BOOST_HANA_STATIC_ASSERT(head(pointers) == type<void*>);
+    BOOST_HANA_CONSTANT_ASSERT(pointers == type_list<void*, int(*)(), char(*)[10]>);
+    BOOST_HANA_CONSTANT_ASSERT(head(pointers) == type<void*>);
     //! [main]
 }
diff --git a/example/type_list/type_list.cpp b/example/type_list/type_list.cpp
index 8301fafb1..76ce0fdd2 100644
--- a/example/type_list/type_list.cpp
+++ b/example/type_list/type_list.cpp
@@ -4,7 +4,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
 #include <boost/hana/type_list.hpp>
@@ -13,7 +13,7 @@ using namespace boost::hana;
 
 int main() {
     //! [main]
-    BOOST_HANA_STATIC_ASSERT(to<List>(type_list<void, int, float>) == list(type<void>, type<int>, type<float>));
-    BOOST_HANA_STATIC_ASSERT(head(type_list<void, int, float>) == type<void>);
+    BOOST_HANA_CONSTANT_ASSERT(to<List>(type_list<void, int, float>) == list(type<void>, type<int>, type<float>));
+    BOOST_HANA_CONSTANT_ASSERT(head(type_list<void, int, float>) == type<void>);
     //! [main]
 }
diff --git a/include/boost/hana/detail/assert.hpp b/include/boost/hana/detail/assert.hpp
new file mode 100644
index 000000000..486bfb5c3
--- /dev/null
+++ b/include/boost/hana/detail/assert.hpp
@@ -0,0 +1,117 @@
+/*!
+@file
+Defines macros to perform different kinds of assertions.
+
+@copyright Louis Dionne 2014
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_HANA_DETAIL_ASSERT_HPP
+#define BOOST_HANA_DETAIL_ASSERT_HPP
+
+#include <boost/hana/constant/constant.hpp>
+#include <boost/hana/core/is_a.hpp>
+
+#include <cassert>
+
+
+namespace boost { namespace hana { namespace assert_detail {
+    // If the argument is not a Constant, we avoid triggering an error or
+    // the second static_assert in BOOST_HANA_CONSTANT_ASSERT.
+    template <typename T, bool = is_a<Constant, datatype_t<T>>>
+    constexpr bool value_helper = true;
+
+    //! @todo
+    //! Consider changing the `value` method so it becomes a variable template
+    //! parameterized on the type of an object.
+    template <typename T>
+    constexpr bool value_helper<T, true> = value(T{});
+}}}
+
+#ifdef BOOST_HANA_DOXYGEN_INVOKED
+    //! @ingroup group-details
+    //! Expands to a runtime assertion.
+    //!
+    //! This macro may only be used at function scope. Its argument must be
+    //! explicitly convertible to a boolean and its data type must not be a
+    //! `Constant`. If the expression is a `Constant`, a static assertion is
+    //! triggered; use `BOOST_HANA_CONSTANT_ASSERT` instead.
+    //!
+    //! Because this macro uses `decltype` on its argument, a lambda may not
+    //! be used inside the expression.
+#   define BOOST_HANA_RUNTIME_ASSERT(...) unspecified
+
+    //! @ingroup group-details
+    //! Compile-time assertion for `Constant`s.
+    //!
+    //! This macro may be used at any scope where a `static_assert` can be
+    //! used. Its argument must be a `Constant`, or else a compile-time
+    //! assertion is triggered. If the argument is a `Constant`, its `value`
+    //! is retrieved, it is converted to a boolean and `static_assert`ed` upon.
+    //!
+    //! Because this macro uses `decltype` on its argument, a lambda may not
+    //! be used inside the expression.
+#   define BOOST_HANA_CONSTANT_ASSERT(...) unspecified
+
+    //! @ingroup group-details
+    //! Expands to a static assertion or a runtime assertion, depending on
+    //! whether `constexpr` lambdas are supported.
+    //!
+    //! This macro is used to assert on a condition that would be a constant
+    //! expression if constexpr lambdas were supported.
+    //!
+    //! This macro may only be used at function scope. Its argument must be
+    //! convertible to a boolean and its data type must not be a `Constant`.
+    //! If the expression is a `Constant`, a static assertion is triggered;
+    //! use `BOOST_HANA_CONSTANT_ASSERT` instead.
+    //!
+    //! Because this macro uses `decltype` on its argument, a lambda may not
+    //! be used inside the expression.
+#   define BOOST_HANA_CONSTEXPR_ASSERT(...) unspecified
+#else
+#   define BOOST_HANA_RUNTIME_ASSERT(...)                                   \
+        static_assert(!::boost::hana::value(                                \
+            ::boost::hana::is_a<                                            \
+                ::boost::hana::Constant,                                    \
+                ::boost::hana::datatype_t<decltype(__VA_ARGS__)>            \
+            >                                                               \
+        ),                                                                  \
+        "the expression (" # __VA_ARGS__ ") yields a Constant; "            \
+        "use BOOST_HANA_CONSTANT_ASSERT instead");                          \
+                                                                            \
+        assert(static_cast<bool>(__VA_ARGS__))                              \
+    /**/
+
+#   define BOOST_HANA_CONSTANT_ASSERT(...)                                  \
+        static_assert(::boost::hana::is_a<                                  \
+            ::boost::hana::Constant,                                        \
+            ::boost::hana::datatype_t<decltype(__VA_ARGS__)>                \
+        >,                                                                  \
+        "the expression (" # __VA_ARGS__ ") does not yield a Constant");    \
+                                                                            \
+        static_assert(::boost::hana::assert_detail::value_helper<           \
+            decltype(__VA_ARGS__)                                           \
+        >, # __VA_ARGS__)                                                   \
+    /**/
+
+#   if 0 // unfortunately, constexpr lambdas are not supported
+#       define BOOST_HANA_CONSTEXPR_ASSERT(...)                             \
+            static_assert(!::boost::hana::value(                            \
+                ::boost::hana::is_a<                                        \
+                    ::boost::hana::Constant,                                \
+                    ::boost::hana::datatype_t<decltype(__VA_ARGS__)>        \
+                >                                                           \
+            ),                                                              \
+            "the expression (" # __VA_ARGS__ ") yields a Constant; "        \
+            "use BOOST_HANA_CONSTANT_ASSERT instead");                      \
+                                                                            \
+            static_assert((__VA_ARGS__), # __VA_ARGS__)                     \
+        /**/
+#   else
+#       define BOOST_HANA_CONSTEXPR_ASSERT(...) \
+            BOOST_HANA_RUNTIME_ASSERT(__VA_ARGS__)
+#   endif
+#endif
+
+#endif // !BOOST_HANA_DETAIL_ASSERT_HPP
diff --git a/include/boost/hana/detail/static_assert.hpp b/include/boost/hana/detail/static_assert.hpp
deleted file mode 100644
index a22b15f5a..000000000
--- a/include/boost/hana/detail/static_assert.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/*!
-@file
-Defines the `BOOST_HANA_STATIC_ASSERT` macro.
-
-@copyright Louis Dionne 2014
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- */
-
-#ifndef BOOST_HANA_DETAIL_STATIC_ASSERT_HPP
-#define BOOST_HANA_DETAIL_STATIC_ASSERT_HPP
-
-#ifdef BOOST_HANA_DOXYGEN_INVOKED
-
-    //! @ingroup group-details
-    //! Expands to a `static_assert` or to an `assert`, depending on
-    //! whether constexpr lambdas are available.
-    //!
-    //! Use this only at function scope. This is a workaround because
-    //! constexpr lambdas are not available yet and so our unit tests
-    //! can't use `static_assert`.
-#   define BOOST_HANA_STATIC_ASSERT(...) static_assert((__VA_ARGS__), "")
-
-#else
-
-#   include <cassert>
-#   define BOOST_HANA_STATIC_ASSERT(...) assert((__VA_ARGS__))
-
-#endif
-
-#endif // !BOOST_HANA_DETAIL_STATIC_ASSERT_HPP
diff --git a/include/boost/hana/type.hpp b/include/boost/hana/type.hpp
index 187725c29..acf93b4ee 100644
--- a/include/boost/hana/type.hpp
+++ b/include/boost/hana/type.hpp
@@ -1,6 +1,6 @@
 /*!
 @file
-Defines `boost::hana::Type`.
+Defines the `boost::hana::Type` data type.
 
 @copyright Louis Dionne 2014
 Distributed under the Boost Software License, Version 1.0.
@@ -18,7 +18,39 @@ Distributed under the Boost Software License, Version 1.0.
 
 namespace boost { namespace hana {
     //! @ingroup group-datatypes
-    //! C++ type represented as a constexpr object.
+    //! Object representing a C++ type.
+    //!
+    //! `Type`s are the key element making it possible to do everything that
+    //! can be done with Boost.MPL also doable with Hana. A `Type` is an
+    //! object of an unspecified type which represents (or wraps) a C++ type.
+    //! However, since it is a regular C++ object, it can be stored in
+    //! heterogeneous containers, passed as an argument to regular functions
+    //! and so on. While representing C++ types as values might seem backward
+    //! at first, it is in fact the very thing that makes it possible to unify
+    //! type-level programming and value-level programming. In particular,
+    //! this allows using the same syntax for type-level computations as used
+    //! in everyday C++, and it even allows certain functions with very few
+    //! requirements to be used both on types and on values, thus reducing
+    //! code duplication. In comparison, previous metaprogramming libraries
+    //! like [Boost.MPL][] or [MPL11][] used struct-based metafunctions that
+    //! worked at the type level only, were less expressive due to the lack
+    //! of anonymous functions and forced the programmer to use an awkward
+    //! syntax.
+    //!
+    //! Of course, since each object of data type `Type` has an unspecified
+    //! (and hence possibly different) C++ type, manipulating these guys
+    //! requires being able to manipulate heterogeneous objects. Fortunately,
+    //! this is exactly what this library was built for, so we're good.
+    //!
+    //! So far, we're only able to pass wrapped types around, which isn't
+    //! very useful. For `Type`s to be of some use, they have to give us
+    //! a way of getting that wrapped type out. Hence, for any `Type` `t`,
+    //! `decltype(t)::type` is an alias to the type it wraps. In Boost.MPL
+    //! parlance, `decltype(t)` is a nullary metafunction returning the C++
+    //! type `t` represents.
+    //!
+    //! [Boost.MPL]: http://www.boost.org/doc/libs/release/libs/mpl/doc/index.html
+    //! [MPL11]: http://github.com/ldionne/mpl11
     //!
     //! ## Instance of
     //! `Comparable`
@@ -31,8 +63,6 @@ namespace boost { namespace hana {
     //!   that's possible.
     //! - Consider having a `.name()` method that would return the
     //!   (demangled?) `typeid(T).name()`.
-    //! - Use more lambdas once http://llvm.org/bugs/show_bug.cgi?id=20046
-    //!   is fixed.
     //!
     //! @bug
     //! `metafunction` and friends are not SFINAE-friendly right now.
diff --git a/test/applicative/ap.cpp b/test/applicative/ap.cpp
index 36a56b049..bfb894da3 100644
--- a/test/applicative/ap.cpp
+++ b/test/applicative/ap.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/applicative/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -25,10 +25,10 @@ void test() {
         return std::make_tuple(xs...);
     };
 
-    BOOST_HANA_STATIC_ASSERT(ap(a(f), a(x<0>)) == a(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(a(f), a(x<0>), a(x<1>)) == a(f(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(ap(a(f), a(x<0>), a(x<1>), a(x<2>)) == a(f(x<0>, x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT(ap(a(f), a(x<0>), a(x<1>), a(x<2>), a(x<3>)) == a(f(x<0>, x<1>, x<2>, x<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(a(f), a(x<0>)) == a(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(a(f), a(x<0>), a(x<1>)) == a(f(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(a(f), a(x<0>), a(x<1>), a(x<2>)) == a(f(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(a(f), a(x<0>), a(x<1>), a(x<2>), a(x<3>)) == a(f(x<0>, x<1>, x<2>, x<3>)));
 }
 
 int main() {
diff --git a/test/applicative/lift.cpp b/test/applicative/lift.cpp
index f9ba53356..06dc379b7 100644
--- a/test/applicative/lift.cpp
+++ b/test/applicative/lift.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/applicative/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,8 +20,8 @@ void test() {
     constexpr auto applicative = detail::minimal::applicative<mcd>;
     using A = detail::minimal::Applicative<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(lift<A>(x<0>) == applicative(x<0>));
-    BOOST_HANA_STATIC_ASSERT(lift<A>(x<1>) == applicative(x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<A>(x<0>) == applicative(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<A>(x<1>) == applicative(x<1>));
 }
 
 int main() {
diff --git a/test/comparable/defaults.cpp b/test/comparable/defaults.cpp
index eb2f04277..526764b26 100644
--- a/test/comparable/defaults.cpp
+++ b/test/comparable/defaults.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/datatype.hpp>
 #include <boost/hana/core/is_a.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
@@ -32,21 +32,21 @@ using Integer2 = datatype_t<integer2>;
 int main() {
     // An instance is provided for EqualityComparable types whose data type
     // is the same as their C++ type.
-    BOOST_HANA_STATIC_ASSERT(equal(integer{0}, integer{0}));
-    BOOST_HANA_STATIC_ASSERT(!equal(integer{0}, integer{1}));
-    BOOST_HANA_STATIC_ASSERT(is_a<Comparable, Integer, Integer>);
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(integer{0}, integer{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(integer{0}, integer{1}));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Comparable, Integer, Integer>);
 
     // No instance is provided when the data type differs from the C++ type,
     // even if the C++ type is EqualityComparable.
-    BOOST_HANA_STATIC_ASSERT(!is_a<Comparable, Integer2, Integer2>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Comparable, Integer2, Integer2>);
 
     // Two objects of different data types are unequal by default.
     struct X { };
     struct Y { };
-    BOOST_HANA_STATIC_ASSERT(is_a<Comparable, X, Y>);
-    BOOST_HANA_STATIC_ASSERT(!equal(X{}, Y{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Comparable, X, Y>);
+    BOOST_HANA_CONSTANT_ASSERT(!equal(X{}, Y{}));
 
     // No instance is provided when the two objects are of the same data type.
-    BOOST_HANA_STATIC_ASSERT(!is_a<Comparable, X, X>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Comparable, Y, Y>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Comparable, X, X>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Comparable, Y, Y>);
 }
diff --git a/test/comparable/equal.cpp b/test/comparable/equal.cpp
index 4fdf8fc1d..1a28561bf 100644
--- a/test/comparable/equal.cpp
+++ b/test/comparable/equal.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/comparable/equal_mcd.hpp>
 #include <boost/hana/comparable/not_equal_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -16,11 +16,11 @@ template <typename mcd>
 void test() {
     constexpr auto comparable = detail::minimal::comparable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(equal(comparable(0), comparable(0)));
-    BOOST_HANA_STATIC_ASSERT(!(equal(comparable(0), comparable(1))));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(comparable(0), comparable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!(equal(comparable(0), comparable(1))));
 
-    BOOST_HANA_STATIC_ASSERT(comparable(0) == comparable(0));
-    BOOST_HANA_STATIC_ASSERT(!(comparable(0) == comparable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(comparable(0) == comparable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(!(comparable(0) == comparable(1)));
 }
 
 int main() {
diff --git a/test/comparable/laws.cpp b/test/comparable/laws.cpp
index 924ee0282..e025f35dc 100644
--- a/test/comparable/laws.cpp
+++ b/test/comparable/laws.cpp
@@ -8,9 +8,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/comparable/laws.hpp>
 #include <boost/hana/comparable/not_equal_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -18,7 +18,7 @@ using namespace boost::hana;
 template <typename mcd>
 void test() {
     constexpr auto comparable = detail::minimal::comparable<mcd>;
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         Comparable::laws::check(
             list(comparable(0), comparable(1), comparable(2))
         )
diff --git a/test/comparable/not_equal.cpp b/test/comparable/not_equal.cpp
index 6ffa88ef5..5a0e10f19 100644
--- a/test/comparable/not_equal.cpp
+++ b/test/comparable/not_equal.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/comparable/equal_mcd.hpp>
 #include <boost/hana/comparable/not_equal_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -16,11 +16,11 @@ template <typename mcd>
 void test() {
     constexpr auto comparable = detail::minimal::comparable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(not_equal(comparable(0), comparable(1)));
-    BOOST_HANA_STATIC_ASSERT(!not_equal(comparable(0), comparable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_equal(comparable(0), comparable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!not_equal(comparable(0), comparable(0)));
 
-    BOOST_HANA_STATIC_ASSERT(comparable(0) != comparable(1));
-    BOOST_HANA_STATIC_ASSERT(!(comparable(0) != comparable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(comparable(0) != comparable(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(!(comparable(0) != comparable(0)));
 }
 
 int main() {
diff --git a/test/constant/comparable/equal.cpp b/test/constant/comparable/equal.cpp
index b56917df7..b9f8b4611 100644
--- a/test/constant/comparable/equal.cpp
+++ b/test/constant/comparable/equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/constant/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/constant.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,15 +20,15 @@ struct UDT {
 
 template <typename mcd, typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT( equal(detail::minimal::constant<T, 0, mcd>, detail::minimal::constant<U, 0, mcd>));
-    BOOST_HANA_STATIC_ASSERT(!equal(detail::minimal::constant<T, 0, mcd>, detail::minimal::constant<U, 1, mcd>));
+    BOOST_HANA_CONSTANT_ASSERT( equal(detail::minimal::constant<T, 0, mcd>, detail::minimal::constant<U, 0, mcd>));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(detail::minimal::constant<T, 0, mcd>, detail::minimal::constant<U, 1, mcd>));
 
     // Incomparable constants must appear as unequal.
-    BOOST_HANA_STATIC_ASSERT(!equal(
+    BOOST_HANA_CONSTANT_ASSERT(!equal(
         detail::minimal::constant<T, 0, mcd>,
         detail::minimal::constant<decltype(&UDT::member1), &UDT::member1, mcd>
     ));
-    BOOST_HANA_STATIC_ASSERT(!equal(
+    BOOST_HANA_CONSTANT_ASSERT(!equal(
         detail::minimal::constant<decltype(&UDT::member1), &UDT::member1, mcd>,
         detail::minimal::constant<decltype(&UDT::member2), &UDT::member2, mcd>
     ));
diff --git a/test/constant/comparable/laws.cpp b/test/constant/comparable/laws.cpp
index 541612428..d79c065a8 100644
--- a/test/constant/comparable/laws.cpp
+++ b/test/constant/comparable/laws.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/constant/mcd.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/constant.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -20,7 +20,7 @@ struct UDT {
 
 template <typename mcd, typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         Comparable::laws::check(
             list(
                 detail::minimal::constant<T, 0, mcd>,
diff --git a/test/constant/laws.cpp b/test/constant/laws.cpp
index eb684a516..db1ce1957 100644
--- a/test/constant/laws.cpp
+++ b/test/constant/laws.cpp
@@ -7,15 +7,15 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/constant/mcd.hpp>
 
 #include <boost/hana/constant/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/constant.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 template <typename mcd, typename T>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(Constant::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Constant::laws::check(
         list(
             detail::minimal::constant<T, 0, mcd>,
             detail::minimal::constant<T, 1, mcd>,
diff --git a/test/core/convert/default.cpp b/test/core/convert/default.cpp
index b60b9ba24..a6a2e1b73 100644
--- a/test/core/convert/default.cpp
+++ b/test/core/convert/default.cpp
@@ -6,9 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/core/convert.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
-#include <cassert>
 #include <string>
 #include <type_traits>
 using namespace boost::hana;
@@ -16,7 +15,7 @@ using namespace boost::hana;
 
 template <typename ToDatatype, typename From, typename To>
 void check_convert(From from, To to_) {
-    assert(to<ToDatatype>(from) == to_);
+    BOOST_HANA_RUNTIME_ASSERT(to<ToDatatype>(from) == to_);
     static_assert(std::is_same<decltype(to<To>(from)), To>{}, "");
 }
 
diff --git a/test/core/convert/specialize.cpp b/test/core/convert/specialize.cpp
index f0c0e8301..2ce16f4ef 100644
--- a/test/core/convert/specialize.cpp
+++ b/test/core/convert/specialize.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/core/convert.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -35,11 +35,11 @@ namespace boost { namespace hana {
 int main() {
     constexpr datatype1 d1{12345};
     BOOST_HANA_CONSTEXPR_LAMBDA datatype2 d2 = to<Datatype2>(d1);
-    BOOST_HANA_STATIC_ASSERT(d2.value == d1.value);
+    BOOST_HANA_CONSTEXPR_ASSERT(d2.value == d1.value);
 
     BOOST_HANA_CONSTEXPR_LAMBDA datatype1 copy1 = to<Datatype1>(d1);
-    BOOST_HANA_STATIC_ASSERT(copy1.value == d1.value);
+    BOOST_HANA_CONSTEXPR_ASSERT(copy1.value == d1.value);
 
     BOOST_HANA_CONSTEXPR_LAMBDA datatype2 copy2 = to<Datatype2>(d2);
-    BOOST_HANA_STATIC_ASSERT(copy2.value == d2.value);
+    BOOST_HANA_CONSTEXPR_ASSERT(copy2.value == d2.value);
 }
diff --git a/test/core/disable.cpp b/test/core/disable.cpp
index 5009480c4..51cb6f8aa 100644
--- a/test/core/disable.cpp
+++ b/test/core/disable.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/is_a.hpp>
 #include <boost/hana/core/typeclass.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
@@ -25,6 +25,6 @@ template <> struct Typeclass::instance<Disabled> : disable { };
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_a<Typeclass, struct AnythingElse>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass, Disabled>);
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Typeclass, struct AnythingElse>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass, Disabled>);
 }
diff --git a/test/core/is_a.cpp b/test/core/is_a.cpp
index 234cf6af5..63063e135 100644
--- a/test/core/is_a.cpp
+++ b/test/core/is_a.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/is_a.hpp>
 #include <boost/hana/core/typeclass.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/foldable/foldable.hpp>
 #include <boost/hana/iterable/iterable.hpp>
 #include <boost/hana/list/instance.hpp>
@@ -36,41 +36,41 @@ struct not_instance { using hana_datatype = NotInstance; };
 
 int main() {
     // standard syntax
-    BOOST_HANA_STATIC_ASSERT(is_a<Typeclass, Instance>);
-    BOOST_HANA_STATIC_ASSERT(is_an<Typeclass, Instance>);
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Typeclass, Instance>);
+    BOOST_HANA_CONSTANT_ASSERT(is_an<Typeclass, Instance>);
 
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass, void>);
-    BOOST_HANA_STATIC_ASSERT(!is_an<Typeclass, void>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass, void>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Typeclass, void>);
 
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass, NotInstance>);
-    BOOST_HANA_STATIC_ASSERT(!is_an<Typeclass, NotInstance>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass, NotInstance>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Typeclass, NotInstance>);
 
-    BOOST_HANA_STATIC_ASSERT(is_a<Typeclass, PredicatedInstance>);
-    BOOST_HANA_STATIC_ASSERT(is_an<Typeclass, PredicatedInstance>);
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Typeclass, PredicatedInstance>);
+    BOOST_HANA_CONSTANT_ASSERT(is_an<Typeclass, PredicatedInstance>);
 
 
     // alternate syntax
-    BOOST_HANA_STATIC_ASSERT(is_a<Typeclass>(an_instance{}));
-    BOOST_HANA_STATIC_ASSERT(is_an<Typeclass>(an_instance{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Typeclass>(an_instance{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_an<Typeclass>(an_instance{}));
 
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass>(not_instance{}));
-    BOOST_HANA_STATIC_ASSERT(!is_an<Typeclass>(not_instance{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass>(not_instance{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Typeclass>(not_instance{}));
 
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass>(1));
-    BOOST_HANA_STATIC_ASSERT(!is_an<Typeclass>(1));
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass>(1));
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Typeclass>(1));
 
-    BOOST_HANA_STATIC_ASSERT(!is_a<Typeclass>('2'));
-    BOOST_HANA_STATIC_ASSERT(!is_an<Typeclass>('2'));
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Typeclass>('2'));
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Typeclass>('2'));
 
     // check with a couple of "real" instances
-    BOOST_HANA_STATIC_ASSERT(is_an<Iterable>(list(1, '2', 3)));
-    BOOST_HANA_STATIC_ASSERT(is_a<Monad>(list(1, '2', 3)));
-    BOOST_HANA_STATIC_ASSERT(is_a<Foldable>(list(1, '2', 3)));
+    BOOST_HANA_CONSTANT_ASSERT(is_an<Iterable>(list(1, '2', 3)));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Monad>(list(1, '2', 3)));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Foldable>(list(1, '2', 3)));
 
-    BOOST_HANA_STATIC_ASSERT(!is_an<Iterable>(just(1)));
-    BOOST_HANA_STATIC_ASSERT(!is_an<Iterable>(nothing));
-    BOOST_HANA_STATIC_ASSERT(is_a<Foldable>(just('1')));
-    BOOST_HANA_STATIC_ASSERT(is_a<Foldable>(nothing));
-    BOOST_HANA_STATIC_ASSERT(is_a<Monad>(just("abcd")));
-    BOOST_HANA_STATIC_ASSERT(is_a<Monad>(nothing));
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Iterable>(just(1)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_an<Iterable>(nothing));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Foldable>(just('1')));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Foldable>(nothing));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Monad>(just("abcd")));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Monad>(nothing));
 }
diff --git a/test/detail/assert.cpp b/test/detail/assert.cpp
new file mode 100644
index 000000000..d696d65d7
--- /dev/null
+++ b/test/detail/assert.cpp
@@ -0,0 +1,32 @@
+/*
+@copyright Louis Dionne 2014
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
+#include <boost/hana/detail/constexpr.hpp>
+using namespace boost::hana;
+
+
+template <int ...>
+auto constant_true = true_;
+
+template <int ...>
+BOOST_HANA_CONSTEXPR_LAMBDA bool constexpr_true = []{ return true; }();
+
+template <int ...>
+bool runtime_true = true;
+
+
+BOOST_HANA_CONSTANT_ASSERT(constant_true<>);
+BOOST_HANA_CONSTANT_ASSERT(constant_true<0, 1>);
+
+int main() {
+    BOOST_HANA_CONSTEXPR_ASSERT(constexpr_true<>);
+    BOOST_HANA_CONSTEXPR_ASSERT(constexpr_true<0, 1>);
+
+    BOOST_HANA_RUNTIME_ASSERT(runtime_true<>);
+    BOOST_HANA_RUNTIME_ASSERT(runtime_true<0, 1>);
+}
diff --git a/test/detail/at_index.cpp b/test/detail/at_index.cpp
index 323ce27be..40612508c 100644
--- a/test/detail/at_index.cpp
+++ b/test/detail/at_index.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/detail/at_index/overload_resolution.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -15,21 +15,21 @@ struct non_pod { virtual ~non_pod() { } };
 
 template <typename At>
 constexpr void test_at(At at) {
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, int_<0>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, int_<0>, int_<1>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, int_<0>, int_<1>, int_<2>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, int_<0>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, int_<0>, int_<1>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, int_<0>, int_<1>, int_<2>) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, int_<0>, int_<1>) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, int_<0>, int_<1>, int_<2>) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<1>, int_<0>, int_<1>) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<1>, int_<0>, int_<1>, int_<2>) == int_<1>);
 
-    BOOST_HANA_STATIC_ASSERT(at(size_t<2>, int_<0>, int_<1>, int_<2>) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<2>, int_<0>, int_<1>, int_<2>) == int_<2>);
 
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, 0) == 0);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, 0, '1') == '1');
-    BOOST_HANA_STATIC_ASSERT(at(size_t<2>, 0, '1', "2") == "2");
+    BOOST_HANA_CONSTEXPR_ASSERT(at(size_t<0>, 0) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(at(size_t<1>, 0, '1') == '1');
+    BOOST_HANA_CONSTEXPR_ASSERT(at(size_t<2>, 0, '1', 2.2) == 2.2);
 
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, int_<0>, non_pod{}) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, non_pod{}, int_<1>) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, int_<0>, non_pod{}) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<1>, non_pod{}, int_<1>) == int_<1>);
 }
 
 int main() {
diff --git a/test/detail/left_folds.cpp b/test/detail/left_folds.cpp
index a41aca3d4..31ebda39a 100644
--- a/test/detail/left_folds.cpp
+++ b/test/detail/left_folds.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/left_folds/variadic.hpp>
 #include <boost/hana/detail/left_folds/variadic_unrolled.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -25,24 +25,24 @@ struct x0; struct x1; struct x2; struct x3;
 
 template <typename Foldl, typename F>
 constexpr void test_foldl(Foldl foldl, F f) {
-    BOOST_HANA_STATIC_ASSERT(foldl(list, int_<0>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(foldl(list, int_<0>, int_<1>) == list(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(list, int_<0>, int_<1>, int_<2>) == list(list(int_<0>, int_<1>), int_<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(list, int_<0>, int_<1>, int_<2>, int_<3>) == list(list(list(int_<0>, int_<1>), int_<2>), int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(list, int_<0>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(foldl(list, int_<0>, int_<1>) == list(int_<0>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(list, int_<0>, int_<1>, int_<2>) == list(list(int_<0>, int_<1>), int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(list, int_<0>, int_<1>, int_<2>, int_<3>) == list(list(list(int_<0>, int_<1>), int_<2>), int_<3>));
 
-    BOOST_HANA_STATIC_ASSERT(foldl(f, type<x0>) == type<x0>);
-    BOOST_HANA_STATIC_ASSERT(foldl(f, type<x0>, type<x1>) == f(type<x0>, type<x1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, type<x0>, type<x1>, type<x2>) == f(f(type<x0>, type<x1>), type<x2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, type<x0>, type<x1>, type<x2>, type<x3>) == f(f(f(type<x0>, type<x1>), type<x2>), type<x3>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(f, type<x0>) == type<x0>);
+    BOOST_HANA_CONSTANT_ASSERT(foldl(f, type<x0>, type<x1>) == f(type<x0>, type<x1>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(f, type<x0>, type<x1>, type<x2>) == f(f(type<x0>, type<x1>), type<x2>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(f, type<x0>, type<x1>, type<x2>, type<x3>) == f(f(f(type<x0>, type<x1>), type<x2>), type<x3>));
 }
 
 template <typename F>
 constexpr void test_foldl_t(F f) {
     using detail::left_folds::variadic_t;
-    BOOST_HANA_STATIC_ASSERT(variadic_t<>(f, type<x0>) == type<x0>);
-    BOOST_HANA_STATIC_ASSERT(variadic_t<x1>(f, type<x0>) == f(type<x0>, type<x1>));
-    BOOST_HANA_STATIC_ASSERT(variadic_t<x1, x2>(f, type<x0>) == f(f(type<x0>, type<x1>), type<x2>));
-    BOOST_HANA_STATIC_ASSERT(variadic_t<x1, x2, x3>(f, type<x0>) == f(f(f(type<x0>, type<x1>), type<x2>), type<x3>));
+    BOOST_HANA_CONSTANT_ASSERT(variadic_t<>(f, type<x0>) == type<x0>);
+    BOOST_HANA_CONSTANT_ASSERT(variadic_t<x1>(f, type<x0>) == f(type<x0>, type<x1>));
+    BOOST_HANA_CONSTANT_ASSERT(variadic_t<x1, x2>(f, type<x0>) == f(f(type<x0>, type<x1>), type<x2>));
+    BOOST_HANA_CONSTANT_ASSERT(variadic_t<x1, x2, x3>(f, type<x0>) == f(f(f(type<x0>, type<x1>), type<x2>), type<x3>));
 }
 
 int main() {
diff --git a/test/detail/wrap.cpp b/test/detail/wrap.cpp
index 55e388c8f..11712e39d 100644
--- a/test/detail/wrap.cpp
+++ b/test/detail/wrap.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/wrap.hpp>
 
 #include <boost/hana/core/datatype.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <type_traits>
 using namespace boost::hana;
@@ -31,5 +31,5 @@ static_assert(std::is_same<
 >::value, "");
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(detail::unwrap(detail::wrap<Datatype>(2.2)) == 2.2);
+    BOOST_HANA_CONSTEXPR_ASSERT(detail::unwrap(detail::wrap<Datatype>(2.2)) == 2.2);
 }
diff --git a/test/ext/boost/fusion/foldable/length.cpp b/test/ext/boost/fusion/foldable/length.cpp
index c09f03d72..9a5bf23e3 100644
--- a/test/ext/boost/fusion/foldable/length.cpp
+++ b/test/ext/boost/fusion/foldable/length.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/fusion.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include "../helper.hpp"
@@ -15,9 +15,9 @@ using namespace boost::hana;
 
 int main() {
     with_nonassociative_forward_sequences([](auto container) {
-        BOOST_HANA_STATIC_ASSERT(length(container()) == size_t<0>);
-        BOOST_HANA_STATIC_ASSERT(length(container(1)) == size_t<1>);
-        BOOST_HANA_STATIC_ASSERT(length(container(1, '2')) == size_t<2>);
-        BOOST_HANA_STATIC_ASSERT(length(container(1, '2', 3.3)) == size_t<3>);
+        BOOST_HANA_CONSTANT_ASSERT(length(container()) == size_t<0>);
+        BOOST_HANA_CONSTANT_ASSERT(length(container(1)) == size_t<1>);
+        BOOST_HANA_CONSTANT_ASSERT(length(container(1, '2')) == size_t<2>);
+        BOOST_HANA_CONSTANT_ASSERT(length(container(1, '2', 3.3)) == size_t<3>);
     });
 }
diff --git a/test/ext/boost/fusion/iterable/is_empty.cpp b/test/ext/boost/fusion/iterable/is_empty.cpp
index d3dabbac8..3f41ebefc 100644
--- a/test/ext/boost/fusion/iterable/is_empty.cpp
+++ b/test/ext/boost/fusion/iterable/is_empty.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/fusion.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include "../helper.hpp"
 using namespace boost::hana;
@@ -14,9 +14,9 @@ using namespace boost::hana;
 
 int main() {
     with_nonassociative_forward_sequences([](auto container) {
-        BOOST_HANA_STATIC_ASSERT(is_empty(container()));
-        BOOST_HANA_STATIC_ASSERT(!is_empty(container(1)));
-        BOOST_HANA_STATIC_ASSERT(!is_empty(container(1, '2')));
-        BOOST_HANA_STATIC_ASSERT(!is_empty(container(1, '2', 3.3)));
+        BOOST_HANA_CONSTANT_ASSERT(is_empty(container()));
+        BOOST_HANA_CONSTANT_ASSERT(!is_empty(container(1)));
+        BOOST_HANA_CONSTANT_ASSERT(!is_empty(container(1, '2')));
+        BOOST_HANA_CONSTANT_ASSERT(!is_empty(container(1, '2', 3.3)));
     });
 }
diff --git a/test/ext/boost/mpl/integral_c/constant/laws.cpp b/test/ext/boost/mpl/integral_c/constant/laws.cpp
index 5d288da92..259011927 100644
--- a/test/ext/boost/mpl/integral_c/constant/laws.cpp
+++ b/test/ext/boost/mpl/integral_c/constant/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/boost/mpl/integral_c.hpp>
 
 #include <boost/hana/constant/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 
 #include <boost/mpl/integral_c.hpp>
@@ -17,7 +17,7 @@ using namespace boost::hana;
 template <typename T>
 void test() {
     namespace mpl = boost::mpl;
-    BOOST_HANA_STATIC_ASSERT(Constant::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Constant::laws::check(
         list(
             mpl::integral_c<T, 0>{},
             mpl::integral_c<T, 1>{},
diff --git a/test/ext/boost/mpl/list/comparable/equal.cpp b/test/ext/boost/mpl/list/comparable/equal.cpp
index 1eabf91aa..948b873d0 100644
--- a/test/ext/boost/mpl/list/comparable/equal.cpp
+++ b/test/ext/boost/mpl/list/comparable/equal.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/mpl/list.hpp>
 using namespace boost::hana;
@@ -16,11 +16,11 @@ namespace mpl = boost::mpl;
 struct x0; struct x1;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::list<>{}, mpl::list<>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::list<x0>{}, mpl::list<>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::list<>{}, mpl::list<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::list<x0>{}, mpl::list<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::list<x0, x1>{}, mpl::list<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::list<x0>{}, mpl::list<x0, x1>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::list<x0, x1>{}, mpl::list<x0, x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::list<>{}, mpl::list<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::list<x0>{}, mpl::list<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::list<>{}, mpl::list<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::list<x0>{}, mpl::list<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::list<x0, x1>{}, mpl::list<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::list<x0>{}, mpl::list<x0, x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::list<x0, x1>{}, mpl::list<x0, x1>{}));
 }
diff --git a/test/ext/boost/mpl/list/comparable/laws.cpp b/test/ext/boost/mpl/list/comparable/laws.cpp
index 6145d6c25..25c1649b0 100644
--- a/test/ext/boost/mpl/list/comparable/laws.cpp
+++ b/test/ext/boost/mpl/list/comparable/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/boost/mpl/list.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 
 #include <boost/mpl/list.hpp>
@@ -20,7 +20,7 @@ template <int ...i>
 constexpr boost::mpl::list<x<i>...> mpl_list{};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         Comparable::laws::check(
             list(
                 mpl_list<>, mpl_list<0>, mpl_list<0, 1>,
diff --git a/test/ext/boost/mpl/list/functor/fmap.cpp b/test/ext/boost/mpl/list/functor/fmap.cpp
index 2938d35f7..05839d12f 100644
--- a/test/ext/boost/mpl/list/functor/fmap.cpp
+++ b/test/ext/boost/mpl/list/functor/fmap.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <boost/mpl/list.hpp>
@@ -20,8 +20,8 @@ struct f;
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(template_<f>, mpl::list<>{}), mpl::list<>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(template_<f>, mpl::list<x0>{}), mpl::list<f<x0>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(template_<f>, mpl::list<x0, x1>{}), mpl::list<f<x0>, f<x1>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(template_<f>, mpl::list<x0, x1, x2>{}), mpl::list<f<x0>, f<x1>, f<x2>>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(fmap(template_<f>, mpl::list<>{}), mpl::list<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(fmap(template_<f>, mpl::list<x0>{}), mpl::list<f<x0>>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(fmap(template_<f>, mpl::list<x0, x1>{}), mpl::list<f<x0>, f<x1>>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(fmap(template_<f>, mpl::list<x0, x1, x2>{}), mpl::list<f<x0>, f<x1>, f<x2>>{}));
 }
diff --git a/test/ext/boost/mpl/list/functor/laws.cpp b/test/ext/boost/mpl/list/functor/laws.cpp
index c4466c5b1..4312b89aa 100644
--- a/test/ext/boost/mpl/list/functor/laws.cpp
+++ b/test/ext/boost/mpl/list/functor/laws.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -25,7 +25,7 @@ struct result {
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Functor::laws::check(
         list(
             mpl::list<>{},
             mpl::list<x0>{},
diff --git a/test/ext/boost/mpl/vector/comparable/equal.cpp b/test/ext/boost/mpl/vector/comparable/equal.cpp
index 770b838b1..2bfd8f01f 100644
--- a/test/ext/boost/mpl/vector/comparable/equal.cpp
+++ b/test/ext/boost/mpl/vector/comparable/equal.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/mpl/vector.hpp>
 using namespace boost::hana;
@@ -16,11 +16,11 @@ namespace mpl = boost::mpl;
 struct x0; struct x1;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::vector<>{}, mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::vector<x0>{}, mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::vector<>{}, mpl::vector<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::vector<x0>{}, mpl::vector<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::vector<x0, x1>{}, mpl::vector<x0>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(mpl::vector<x0>{}, mpl::vector<x0, x1>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(mpl::vector<x0, x1>{}, mpl::vector<x0, x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::vector<>{}, mpl::vector<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::vector<x0>{}, mpl::vector<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::vector<>{}, mpl::vector<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::vector<x0>{}, mpl::vector<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::vector<x0, x1>{}, mpl::vector<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(mpl::vector<x0>{}, mpl::vector<x0, x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(mpl::vector<x0, x1>{}, mpl::vector<x0, x1>{}));
 }
diff --git a/test/ext/boost/mpl/vector/comparable/laws.cpp b/test/ext/boost/mpl/vector/comparable/laws.cpp
index 5414c879a..ca8c3ca4c 100644
--- a/test/ext/boost/mpl/vector/comparable/laws.cpp
+++ b/test/ext/boost/mpl/vector/comparable/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 
 #include <boost/mpl/vector.hpp>
@@ -20,7 +20,7 @@ template <int ...i>
 constexpr boost::mpl::vector<x<i>...> mpl_vector{};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         Comparable::laws::check(
             list(
                 mpl_vector<>, mpl_vector<0>, mpl_vector<0, 1>,
diff --git a/test/ext/boost/mpl/vector/functor/fmap.cpp b/test/ext/boost/mpl/vector/functor/fmap.cpp
index cf9d7458d..4119550fd 100644
--- a/test/ext/boost/mpl/vector/functor/fmap.cpp
+++ b/test/ext/boost/mpl/vector/functor/fmap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <boost/mpl/vector.hpp>
@@ -24,14 +24,14 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto t) {
 
 struct x0; struct x1; struct x2;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(f, mpl::vector<>{}), mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(f, mpl::vector<x0>{}), mpl::vector<F<x0>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(f, mpl::vector<x0, x1>{}), mpl::vector<F<x0>, F<x1>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(f, mpl::vector<x0, x1, x2>{}), mpl::vector<F<x0>, F<x1>, F<x2>>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(f, mpl::vector<>{}), mpl::vector<>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(f, mpl::vector<x0>{}), mpl::vector<F<x0>>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(f, mpl::vector<x0, x1>{}), mpl::vector<F<x0>, F<x1>>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(f, mpl::vector<x0, x1, x2>{}), mpl::vector<F<x0>, F<x1>, F<x2>>{}));
 
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(g, mpl::vector<>{}), mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(g, mpl::vector<x0>{}), mpl::vector<F<x0>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(g, mpl::vector<x0, x1>{}), mpl::vector<F<x0>, F<x1>>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(fmap(g, mpl::vector<x0, x1, x2>{}), mpl::vector<F<x0>, F<x1>, F<x2>>{}));
-}
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(g, mpl::vector<>{}), mpl::vector<>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(g, mpl::vector<x0>{}), mpl::vector<F<x0>>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(g, mpl::vector<x0, x1>{}), mpl::vector<F<x0>, F<x1>>{}));
+BOOST_HANA_CONSTANT_ASSERT(equal(fmap(g, mpl::vector<x0, x1, x2>{}), mpl::vector<F<x0>, F<x1>, F<x2>>{}));
+
+int main() { (void)g; }
diff --git a/test/ext/boost/mpl/vector/functor/laws.cpp b/test/ext/boost/mpl/vector/functor/laws.cpp
index b57dc72ab..aec568c35 100644
--- a/test/ext/boost/mpl/vector/functor/laws.cpp
+++ b/test/ext/boost/mpl/vector/functor/laws.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/type.hpp>
@@ -25,7 +25,7 @@ struct result {
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Functor::laws::check(
         list(
             mpl::vector<>{},
             mpl::vector<x0>{},
diff --git a/test/ext/boost/mpl/vector/iterable/head.cpp b/test/ext/boost/mpl/vector/iterable/head.cpp
index 7d7b2c0ce..6e6487d74 100644
--- a/test/ext/boost/mpl/vector/iterable/head.cpp
+++ b/test/ext/boost/mpl/vector/iterable/head.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <boost/mpl/vector.hpp>
@@ -17,7 +17,7 @@ namespace mpl = boost::mpl;
 struct x1; struct x2; struct x3;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(head(mpl::vector<x1>{}) == type<x1>);
-    BOOST_HANA_STATIC_ASSERT(head(mpl::vector<x1, x2>{}) == type<x1>);
-    BOOST_HANA_STATIC_ASSERT(head(mpl::vector<x1, x2, x3>{}) == type<x1>);
+    BOOST_HANA_CONSTANT_ASSERT(head(mpl::vector<x1>{}) == type<x1>);
+    BOOST_HANA_CONSTANT_ASSERT(head(mpl::vector<x1, x2>{}) == type<x1>);
+    BOOST_HANA_CONSTANT_ASSERT(head(mpl::vector<x1, x2, x3>{}) == type<x1>);
 }
diff --git a/test/ext/boost/mpl/vector/iterable/is_empty.cpp b/test/ext/boost/mpl/vector/iterable/is_empty.cpp
index 2210de9d1..9ea14f57d 100644
--- a/test/ext/boost/mpl/vector/iterable/is_empty.cpp
+++ b/test/ext/boost/mpl/vector/iterable/is_empty.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/mpl/vector.hpp>
 using namespace boost::hana;
@@ -14,12 +14,12 @@ namespace mpl = boost::mpl;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(is_empty(mpl::vector0<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(mpl::vector<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(mpl::vector0<>{}));
 
-    BOOST_HANA_STATIC_ASSERT(!is_empty(mpl::vector<int>{}));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(mpl::vector1<int>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(mpl::vector<int>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(mpl::vector1<int>{}));
 
-    BOOST_HANA_STATIC_ASSERT(!is_empty(mpl::vector<int, char>{}));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(mpl::vector2<int, char>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(mpl::vector<int, char>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(mpl::vector2<int, char>{}));
 }
diff --git a/test/ext/boost/mpl/vector/iterable/tail.cpp b/test/ext/boost/mpl/vector/iterable/tail.cpp
index 234929a54..8420166a0 100644
--- a/test/ext/boost/mpl/vector/iterable/tail.cpp
+++ b/test/ext/boost/mpl/vector/iterable/tail.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/mpl/vector.hpp>
 using namespace boost::hana;
@@ -16,7 +16,7 @@ namespace mpl = boost::mpl;
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(tail(mpl::vector<x0>{}), mpl::vector<>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(tail(mpl::vector<x0, x1>{}), mpl::vector<x1>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(tail(mpl::vector<x0, x1, x2>{}), mpl::vector<x1, x2>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(mpl::vector<x0>{}), mpl::vector<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(mpl::vector<x0, x1>{}), mpl::vector<x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(mpl::vector<x0, x1, x2>{}), mpl::vector<x1, x2>{}));
 }
diff --git a/test/ext/boost/mpl/vector/list/cons.cpp b/test/ext/boost/mpl/vector/list/cons.cpp
index f75d78299..c3a897652 100644
--- a/test/ext/boost/mpl/vector/list/cons.cpp
+++ b/test/ext/boost/mpl/vector/list/cons.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <boost/mpl/vector.hpp>
@@ -17,8 +17,7 @@ namespace mpl = boost::mpl;
 struct x0; struct x1; struct x2;
 
 int main() {
-    using namespace operators;
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, mpl::vector<>{}) == mpl::vector<x0>{});
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, mpl::vector<x1>{}) == mpl::vector<x0, x1>{});
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, mpl::vector<x1, x2>{}) == mpl::vector<x0, x1, x2>{});
+    BOOST_HANA_CONSTANT_ASSERT(equal(cons(type<x0>, mpl::vector<>{}), mpl::vector<x0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(cons(type<x0>, mpl::vector<x1>{}), mpl::vector<x0, x1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(cons(type<x0>, mpl::vector<x1, x2>{}), mpl::vector<x0, x1, x2>{}));
 }
diff --git a/test/ext/boost/mpl/vector/list/nil.cpp b/test/ext/boost/mpl/vector/list/nil.cpp
index b16cf9a71..83440ead5 100644
--- a/test/ext/boost/mpl/vector/list/nil.cpp
+++ b/test/ext/boost/mpl/vector/list/nil.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/mpl/vector.hpp>
 using namespace boost::hana;
@@ -14,7 +14,6 @@ namespace mpl = boost::mpl;
 
 
 int main() {
-    using namespace operators;
-    BOOST_HANA_STATIC_ASSERT(nil<MplVector> == mpl::vector<>{});
-    BOOST_HANA_STATIC_ASSERT(nil<MplVector> == mpl::vector0<>{});
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<MplVector>, mpl::vector<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<MplVector>, mpl::vector0<>{}));
 }
diff --git a/test/ext/boost/tuple/iterable/is_empty.cpp b/test/ext/boost/tuple/iterable/is_empty.cpp
index d81aefd29..cc9ab18fd 100644
--- a/test/ext/boost/tuple/iterable/is_empty.cpp
+++ b/test/ext/boost/tuple/iterable/is_empty.cpp
@@ -6,17 +6,17 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/boost/tuple.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <boost/tuple/tuple.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(boost::make_tuple()));
-    BOOST_HANA_STATIC_ASSERT(is_empty(boost::tuples::null_type{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(boost::make_tuple()));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(boost::tuples::null_type{}));
 
-    BOOST_HANA_STATIC_ASSERT(!is_empty(boost::make_tuple(1)));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(boost::make_tuple(1, '2')));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(boost::make_tuple(1, '2', 3.3)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(boost::make_tuple(1)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(boost::make_tuple(1, '2')));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(boost::make_tuple(1, '2', 3.3)));
 }
diff --git a/test/ext/std/array/iterable/head.cpp b/test/ext/std/array/iterable/head.cpp
index 4a1ec77f6..446085820 100644
--- a/test/ext/std/array/iterable/head.cpp
+++ b/test/ext/std/array/iterable/head.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/array.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <array>
 using namespace boost::hana;
@@ -16,7 +16,7 @@ template <int ...i>
 constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(head(array<0>) == 0);
-    BOOST_HANA_STATIC_ASSERT(head(array<0, 1>) == 0);
-    BOOST_HANA_STATIC_ASSERT(head(array<0, 1, 2>) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(array<0>) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(array<0, 1>) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(array<0, 1, 2>) == 0);
 }
diff --git a/test/ext/std/array/iterable/is_empty.cpp b/test/ext/std/array/iterable/is_empty.cpp
index 287509685..0ed2a8495 100644
--- a/test/ext/std/array/iterable/is_empty.cpp
+++ b/test/ext/std/array/iterable/is_empty.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/array.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <array>
 using namespace boost::hana;
@@ -16,7 +16,7 @@ template <int ...i>
  auto array = std::array<int, sizeof...(i)>{{i...}};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(array<>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(array<0>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(array<0, 1>));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(array<>));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(array<0>));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(array<0, 1>));
 }
diff --git a/test/ext/std/array/iterable/tail.cpp b/test/ext/std/array/iterable/tail.cpp
index 8d78c432e..0c38b0013 100644
--- a/test/ext/std/array/iterable/tail.cpp
+++ b/test/ext/std/array/iterable/tail.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/array.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <array>
 using namespace boost::hana;
@@ -16,8 +16,8 @@ template <int ...i>
 constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(tail(array<0>) == array<>);
-    BOOST_HANA_STATIC_ASSERT(tail(array<0, 1>) == array<1>);
-    BOOST_HANA_STATIC_ASSERT(tail(array<0, 1, 2>) == array<1, 2>);
-    BOOST_HANA_STATIC_ASSERT(tail(array<0, 1, 2, 3>) == array<1, 2, 3>);
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(array<0>), array<>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(tail(array<0, 1>), array<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(tail(array<0, 1, 2>), array<1, 2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(tail(array<0, 1, 2, 3>), array<1, 2, 3>));
 }
diff --git a/test/ext/std/array/list/cons.cpp b/test/ext/std/array/list/cons.cpp
index 6757db82b..6c3cfe4e1 100644
--- a/test/ext/std/array/list/cons.cpp
+++ b/test/ext/std/array/list/cons.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/array.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <array>
 using namespace boost::hana;
@@ -16,10 +16,10 @@ template <int ...i>
 constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(cons(0, array<>), array<0>));
-    BOOST_HANA_STATIC_ASSERT(equal(cons(0, array<1>), array<0, 1>));
-    BOOST_HANA_STATIC_ASSERT(equal(cons(0, array<1, 2>), array<0, 1, 2>));
-    BOOST_HANA_STATIC_ASSERT(equal(cons(0, array<1, 2, 3>), array<0, 1, 2, 3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, array<>), array<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, array<1>), array<0, 1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, array<1, 2>), array<0, 1, 2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, array<1, 2, 3>), array<0, 1, 2, 3>));
 
-    BOOST_HANA_STATIC_ASSERT(equal(cons(0, nil<StdArray>), array<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, nil<StdArray>), array<0>));
 }
diff --git a/test/ext/std/array/list/nil.cpp b/test/ext/std/array/list/nil.cpp
index fdb6637ae..6c9f31acb 100644
--- a/test/ext/std/array/list/nil.cpp
+++ b/test/ext/std/array/list/nil.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/array.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <array>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(nil<StdArray>, std::array<char, 0>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(nil<StdArray>, std::array<int, 0>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(nil<StdArray>, std::array<long, 0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<StdArray>, std::array<char, 0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<StdArray>, std::array<int, 0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<StdArray>, std::array<long, 0>{}));
 }
diff --git a/test/ext/std/integer_sequence/comparable/equal.cpp b/test/ext/std/integer_sequence/comparable/equal.cpp
index 26ba320c0..e499e7e51 100644
--- a/test/ext/std/integer_sequence/comparable/equal.cpp
+++ b/test/ext/std/integer_sequence/comparable/equal.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/integer_sequence.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <utility>
 using namespace boost::hana;
@@ -14,16 +14,16 @@ using namespace boost::hana;
 
 template <typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(equal(std::integer_sequence<T>{}, std::integer_sequence<U>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(std::integer_sequence<T>{}, std::integer_sequence<U, 0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(std::integer_sequence<T>{}, std::integer_sequence<U>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(std::integer_sequence<T>{}, std::integer_sequence<U, 0>{}));
 
-    BOOST_HANA_STATIC_ASSERT(equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U, 0>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U, 0, 1>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(std::integer_sequence<T, 0, 2>{}, std::integer_sequence<U, 0, 1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U, 0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(std::integer_sequence<T, 0>{}, std::integer_sequence<U, 0, 1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(std::integer_sequence<T, 0, 2>{}, std::integer_sequence<U, 0, 1>{}));
 
-    BOOST_HANA_STATIC_ASSERT(equal(std::integer_sequence<T, 0, 1, 2, 3>{}, std::integer_sequence<U, 0, 1, 2, 3>{}));
-    BOOST_HANA_STATIC_ASSERT(!equal(std::integer_sequence<T, 0, 1, 2, 3, 5>{}, std::integer_sequence<U, 0, 1, 2, 3>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(std::integer_sequence<T, 0, 1, 2, 3>{}, std::integer_sequence<U, 0, 1, 2, 3>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(std::integer_sequence<T, 0, 1, 2, 3, 5>{}, std::integer_sequence<U, 0, 1, 2, 3>{}));
 }
 
 template <typename T>
diff --git a/test/ext/std/integer_sequence/comparable/laws.cpp b/test/ext/std/integer_sequence/comparable/laws.cpp
index 29620e048..4c2fd16fe 100644
--- a/test/ext/std/integer_sequence/comparable/laws.cpp
+++ b/test/ext/std/integer_sequence/comparable/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/std/integer_sequence.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 
 #include <utility>
@@ -16,7 +16,7 @@ using namespace boost::hana;
 
 template <typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(
         Comparable::laws::check(
             list(
                 std::integer_sequence<T>{},
diff --git a/test/ext/std/integer_sequence/iterable/head.cpp b/test/ext/std/integer_sequence/iterable/head.cpp
index d9f536242..d6e754234 100644
--- a/test/ext/std/integer_sequence/iterable/head.cpp
+++ b/test/ext/std/integer_sequence/iterable/head.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/integer_sequence.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <utility>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(head(std::index_sequence<0>{}) == 0);
-    BOOST_HANA_STATIC_ASSERT(head(std::index_sequence<0, 1>{}) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(std::index_sequence<0>{}) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(head(std::index_sequence<0, 1>{}) == 0);
 }
diff --git a/test/ext/std/integer_sequence/iterable/is_empty.cpp b/test/ext/std/integer_sequence/iterable/is_empty.cpp
index 6171a265c..94e87c4f9 100644
--- a/test/ext/std/integer_sequence/iterable/is_empty.cpp
+++ b/test/ext/std/integer_sequence/iterable/is_empty.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/integer_sequence.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <utility>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(std::index_sequence<>{}));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(std::index_sequence<0>{}));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(std::index_sequence<1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(std::index_sequence<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(std::index_sequence<0>{}));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(std::index_sequence<1>{}));
 }
diff --git a/test/ext/std/integer_sequence/iterable/tail.cpp b/test/ext/std/integer_sequence/iterable/tail.cpp
index caaecf2ed..f9a0a0552 100644
--- a/test/ext/std/integer_sequence/iterable/tail.cpp
+++ b/test/ext/std/integer_sequence/iterable/tail.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/integer_sequence.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <utility>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(equal(tail(std::index_sequence<0>{}), std::index_sequence<>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(tail(std::index_sequence<0, 1>{}), std::index_sequence<1>{}));
-    BOOST_HANA_STATIC_ASSERT(equal(tail(std::index_sequence<0, 1, 2>{}), std::index_sequence<1, 2>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::index_sequence<0>{}), std::index_sequence<>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::index_sequence<0, 1>{}), std::index_sequence<1>{}));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::index_sequence<0, 1, 2>{}), std::index_sequence<1, 2>{}));
 }
diff --git a/test/ext/std/integral_constant/api.cpp b/test/ext/std/integral_constant/api.cpp
deleted file mode 100644
index f2d298e0a..000000000
--- a/test/ext/std/integral_constant/api.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-@copyright Louis Dionne 2014
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- */
-
-#include <boost/hana/ext/std/integral_constant.hpp>
-
-#include <boost/hana/detail/static_assert.hpp>
-#include <boost/hana/type.hpp>
-
-#include <cstddef>
-#include <type_traits>
-using namespace boost::hana;
-
-
-int main() {
-    // operator()
-    static_assert(std::integral_constant<std::size_t, 0>{}() == 0, "");
-    static_assert(std::integral_constant<std::size_t, 1>{}() == 1, "");
-    static_assert(std::integral_constant<int, -3>{}() == -3, "");
-
-    // decltype(operator())
-    BOOST_HANA_STATIC_ASSERT(decltype_(std::integral_constant<std::size_t, 0>{}()) == type<std::size_t>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(std::integral_constant<int, -3>{}()) == type<int>);
-
-    // conversions
-    constexpr std::size_t a = std::integral_constant<std::size_t, 0>{}, b = std::integral_constant<std::size_t, 1>{};
-    static_assert(a == 0 && b == 1, "");
-
-    constexpr int c = std::integral_constant<int, 0>{}, d = std::integral_constant<int, -3>{};
-    static_assert(c == 0 && d == -3, "");
-}
diff --git a/test/ext/std/integral_constant/integral_interop.cpp b/test/ext/std/integral_constant/integral_interop.cpp
index 32f4c6314..681311671 100644
--- a/test/ext/std/integral_constant/integral_interop.cpp
+++ b/test/ext/std/integral_constant/integral_interop.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/integral_constant.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <type_traits>
@@ -14,8 +14,8 @@ using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(std::integral_constant<int, 1>{} == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(std::integral_constant<int, 1>{} == long_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(std::integral_constant<int, 1>{} == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(std::integral_constant<int, 1>{} == long_<1>);
 
-    BOOST_HANA_STATIC_ASSERT(std::integral_constant<int, 2>{} != int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(std::integral_constant<int, 2>{} != int_<3>);
 }
diff --git a/test/ext/std/pair/pair.cpp b/test/ext/std/pair/pair.cpp
index 355b35be4..cf5278899 100644
--- a/test/ext/std/pair/pair.cpp
+++ b/test/ext/std/pair/pair.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/pair.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <utility>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(first(std::make_pair(1, '2')) == 1);
-    BOOST_HANA_STATIC_ASSERT(second(std::make_pair(1, '2')) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(first(std::make_pair(1, '2')) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(std::make_pair(1, '2')) == '2');
 }
diff --git a/test/ext/std/tuple/applicative.cpp b/test/ext/std/tuple/applicative.cpp
index c0bc68659..3800a003d 100644
--- a/test/ext/std/tuple/applicative.cpp
+++ b/test/ext/std/tuple/applicative.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -27,22 +27,22 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto ...xs) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lift<StdTuple>(int_<0>) == tuple(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(lift<StdTuple>(int_<1>) == tuple(int_<1>));
-    BOOST_HANA_STATIC_ASSERT(lift<StdTuple>(3) == tuple(3));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<StdTuple>(int_<0>) == tuple(int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<StdTuple>(int_<1>) == tuple(int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<StdTuple>(3) == tuple(3));
 
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(), tuple()) == tuple());
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(), tuple(1)) == tuple());
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(), tuple(1, '2')) == tuple());
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(), tuple(1, '2', 3.3)) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(), tuple()) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(), tuple(1)) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(), tuple(1, '2')) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(), tuple(1, '2', 3.3)) == tuple());
 
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f), tuple()) == tuple());
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f), tuple(1)) == tuple(f(1)));
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f), tuple(1, '2')) == tuple(f(1), f('2')));
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f), tuple(1, '2', 3.3)) == tuple(f(1), f('2'), f(3.3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f), tuple()) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f), tuple(1)) == tuple(f(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f), tuple(1, '2')) == tuple(f(1), f('2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f), tuple(1, '2', 3.3)) == tuple(f(1), f('2'), f(3.3)));
 
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f, g), tuple()) == tuple());
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f, g), tuple(1)) == tuple(f(1), g(1)));
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f, g), tuple(1, '2')) == tuple(f(1), f('2'), g(1), g('2')));
-    BOOST_HANA_STATIC_ASSERT(ap(tuple(f, g), tuple(1, '2', 3.3)) == tuple(f(1), f('2'), f(3.3), g(1), g('2'), g(3.3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f, g), tuple()) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f, g), tuple(1)) == tuple(f(1), g(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f, g), tuple(1, '2')) == tuple(f(1), f('2'), g(1), g('2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(tuple(f, g), tuple(1, '2', 3.3)) == tuple(f(1), f('2'), f(3.3), g(1), g('2'), g(3.3)));
 }
diff --git a/test/ext/std/tuple/bugs/libcxx_19616.cpp b/test/ext/std/tuple/bugs/libcxx_19616.cpp
index e53ac1f25..e11642e7f 100644
--- a/test/ext/std/tuple/bugs/libcxx_19616.cpp
+++ b/test/ext/std/tuple/bugs/libcxx_19616.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -15,10 +15,10 @@ using namespace boost::hana;
 int main() {
     // Make sure we workaround the bug at:
     // http://llvm.org/bugs/show_bug.cgi?id=19616
-    BOOST_HANA_STATIC_ASSERT(
-        lift<StdTuple>(std::make_tuple(1)) ==
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(
+        lift<StdTuple>(std::make_tuple(1)),
         std::make_tuple(std::make_tuple(1))
-    );
+    ));
 
     // The following shows the actual bug:
 #if 0
diff --git a/test/ext/std/tuple/functor/fmap.cpp b/test/ext/std/tuple/functor/fmap.cpp
index 7678600a5..b596e2e3e 100644
--- a/test/ext/std/tuple/functor/fmap.cpp
+++ b/test/ext/std/tuple/functor/fmap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -17,8 +17,8 @@ using namespace boost::hana;
 BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto i) { return i + int_<1>; };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(fmap(f, std::make_tuple()) == std::make_tuple());
-    BOOST_HANA_STATIC_ASSERT(fmap(f, std::make_tuple(int_<1>)) == std::make_tuple(f(int_<1>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, std::make_tuple(int_<1>, int_<2>)) == std::make_tuple(f(int_<1>), f(int_<2>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, std::make_tuple(int_<1>, int_<2>, int_<3>)) == std::make_tuple(f(int_<1>), f(int_<2>), f(int_<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, std::make_tuple()) == std::make_tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, std::make_tuple(int_<1>)) == std::make_tuple(f(int_<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, std::make_tuple(int_<1>, int_<2>)) == std::make_tuple(f(int_<1>), f(int_<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, std::make_tuple(int_<1>, int_<2>, int_<3>)) == std::make_tuple(f(int_<1>), f(int_<2>), f(int_<3>)));
 }
diff --git a/test/ext/std/tuple/functor/laws.cpp b/test/ext/std/tuple/functor/laws.cpp
index 9bc25837b..cbba3eab6 100644
--- a/test/ext/std/tuple/functor/laws.cpp
+++ b/test/ext/std/tuple/functor/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 #include <boost/hana/list/instance.hpp>
 
@@ -29,7 +29,7 @@ template <int i, int j>
 constexpr _f<i, j> f{};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(
             std::make_tuple(),
             std::make_tuple(x<0>),
diff --git a/test/ext/std/tuple/iterable.cpp b/test/ext/std/tuple/iterable.cpp
index bd2720860..85450dc95 100644
--- a/test/ext/std/tuple/iterable.cpp
+++ b/test/ext/std/tuple/iterable.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -14,14 +14,14 @@ using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(std::make_tuple()));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(std::make_tuple(int_<0>)));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(std::make_tuple(int_<0>, int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(std::make_tuple()));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(std::make_tuple(int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(std::make_tuple(int_<0>, int_<1>)));
 
-    BOOST_HANA_STATIC_ASSERT(head(std::make_tuple(int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(std::make_tuple(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(std::make_tuple(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(std::make_tuple(int_<0>, int_<1>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(tail(std::make_tuple(int_<0>)) == std::make_tuple());
-    BOOST_HANA_STATIC_ASSERT(tail(std::make_tuple(int_<0>, int_<1>)) == std::make_tuple(int_<1>));
-    BOOST_HANA_STATIC_ASSERT(tail(std::make_tuple(int_<0>, int_<1>, int_<2>)) == std::make_tuple(int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::make_tuple(int_<0>)), std::make_tuple()));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::make_tuple(int_<0>, int_<1>)), std::make_tuple(int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(equal(tail(std::make_tuple(int_<0>, int_<1>, int_<2>)), std::make_tuple(int_<1>, int_<2>)));
 }
diff --git a/test/ext/std/tuple/list/cons.cpp b/test/ext/std/tuple/list/cons.cpp
index f3e283dd6..7a900bb82 100644
--- a/test/ext/std/tuple/list/cons.cpp
+++ b/test/ext/std/tuple/list/cons.cpp
@@ -6,15 +6,15 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(cons(0, std::make_tuple()) == std::make_tuple(0));
-    BOOST_HANA_STATIC_ASSERT(cons(0, std::make_tuple('1')) == std::make_tuple(0, '1'));
-    BOOST_HANA_STATIC_ASSERT(cons(0, std::make_tuple('1', 2.2)) == std::make_tuple(0, '1', 2.2));
-    BOOST_HANA_STATIC_ASSERT(cons(0, std::make_tuple('1', 2.2, nullptr)) == std::make_tuple(0, '1', 2.2, nullptr));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, std::make_tuple()), std::make_tuple(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, std::make_tuple('1')), std::make_tuple(0, '1')));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, std::make_tuple('1', 2.2)), std::make_tuple(0, '1', 2.2)));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(cons(0, std::make_tuple('1', 2.2, nullptr)), std::make_tuple(0, '1', 2.2, nullptr)));
 }
diff --git a/test/ext/std/tuple/list/nil.cpp b/test/ext/std/tuple/list/nil.cpp
index 6187980aa..6a8b410cc 100644
--- a/test/ext/std/tuple/list/nil.cpp
+++ b/test/ext/std/tuple/list/nil.cpp
@@ -6,12 +6,12 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(nil<StdTuple> == std::make_tuple());
+    BOOST_HANA_CONSTANT_ASSERT(equal(nil<StdTuple>, std::make_tuple()));
 }
diff --git a/test/ext/std/tuple/monad/flatten.cpp b/test/ext/std/tuple/monad/flatten.cpp
index cf2b8aab4..260ffaabb 100644
--- a/test/ext/std/tuple/monad/flatten.cpp
+++ b/test/ext/std/tuple/monad/flatten.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -19,11 +19,11 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto tuple = [](auto ...xs) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(flatten(tuple(tuple(), tuple())) == tuple());
-    BOOST_HANA_STATIC_ASSERT(flatten(tuple(tuple(int_<0>), tuple())) == tuple(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(tuple(tuple(), tuple(int_<0>))) == tuple(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(tuple(tuple(int_<0>), tuple(int_<1>))) == tuple(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(tuple(tuple(), tuple())) == tuple());
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(tuple(tuple(int_<0>), tuple())) == tuple(int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(tuple(tuple(), tuple(int_<0>))) == tuple(int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(tuple(tuple(int_<0>), tuple(int_<1>))) == tuple(int_<0>, int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(
         flatten(tuple(tuple(0, int_<1>), tuple(), tuple('2', 3.3), tuple(int_<4>)))
         ==
         tuple(0, int_<1>, '2', 3.3, int_<4>)
diff --git a/test/ext/std/tuple/monad/laws.cpp b/test/ext/std/tuple/monad/laws.cpp
index 438838815..6068149e9 100644
--- a/test/ext/std/tuple/monad/laws.cpp
+++ b/test/ext/std/tuple/monad/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/ext/std/tuple.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/monad/laws.hpp>
 
@@ -24,8 +24,8 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(std::make_tuple(), int_<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(std::make_tuple(int_<1>), int_<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(std::make_tuple(int_<1>, int_<2>), int_<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(std::make_tuple(1, 2, 3, 4), int_<1>, f, g));
+    BOOST_HANA_CONSTANT_ASSERT(Monad::laws::check(std::make_tuple(), int_<1>, f, g));
+    BOOST_HANA_CONSTANT_ASSERT(Monad::laws::check(std::make_tuple(int_<1>), int_<1>, f, g));
+    BOOST_HANA_CONSTANT_ASSERT(Monad::laws::check(std::make_tuple(int_<1>, int_<2>), int_<1>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(std::make_tuple(1, 2, 3, 4), int_<1>, f, g));
 }
diff --git a/test/foldable/count.cpp b/test/foldable/count.cpp
index bb73b01fb..f25dfcfc6 100644
--- a/test/foldable/count.cpp
+++ b/test/foldable/count.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -21,43 +21,41 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    // compile-time
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable()) == size_t<0>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>)) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable()) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>)) == size_t<0>);
 
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<1>)) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<0>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<1>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<0>)) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<1>)) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<0>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<1>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<0>)) == size_t<0>);
 
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<1>, long_<1>)) == size_t<3>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<1>, long_<0>)) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<0>, long_<1>)) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<1>, char_<0>, long_<0>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<1>, long_<1>)) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<1>, long_<0>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<0>, long_<1>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int_<0>, char_<0>, long_<0>)) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<1>, long_<1>)) == size_t<3>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<1>, long_<0>)) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<0>, long_<1>)) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<1>, char_<0>, long_<0>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<1>, long_<1>)) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<1>, long_<0>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<0>, long_<1>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(count(f, foldable(int_<0>, char_<0>, long_<0>)) == size_t<0>);
 
 
-    // constexpr/runtime
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0})) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0})) == 0);
 
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{1})) == 2);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{0})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{1})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{0})) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{1})) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{0})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{1})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{0})) == 0);
 
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{1}, double{1})) == 3);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{1}, double{0})) == 2);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{0}, double{1})) == 2);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{1}, char{0}, double{0})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{1}, double{1})) == 2);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{1}, double{0})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{0}, double{1})) == 1);
-    BOOST_HANA_STATIC_ASSERT(count(f, foldable(int{0}, char{0}, double{0})) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{1}, double{1})) == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{1}, double{0})) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{0}, double{1})) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{1}, char{0}, double{0})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{1}, double{1})) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{1}, double{0})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{0}, double{1})) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(count(f, foldable(int{0}, char{0}, double{0})) == 0);
 }
 
 int main() {
diff --git a/test/foldable/foldl.cpp b/test/foldable/foldl.cpp
index b9dfbd522..21bfb6210 100644
--- a/test/foldable/foldl.cpp
+++ b/test/foldable/foldl.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -24,16 +24,16 @@ void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
     constexpr std::tuple<> s;
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable()) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(1)) == f(s, 1));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(1, '2')) == f(f(s, 1), '2'));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(1, '2', 3.3)) == f(f(f(s, 1), '2'), 3.3));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(1, '2', 3.3, 4.4f)) == f(f(f(f(s, 1), '2'), 3.3), 4.4f));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable()) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(1)) == f(s, 1));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(1, '2')) == f(f(s, 1), '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(1, '2', 3.3)) == f(f(f(s, 1), '2'), 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(1, '2', 3.3, 4.4f)) == f(f(f(f(s, 1), '2'), 3.3), 4.4f));
 
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(int_<1>)) == f(s, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>)) == f(f(s, int_<1>), int_<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>, int_<3>)) == f(f(f(s, int_<1>), int_<2>), int_<3>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>, int_<3>, int_<4>)) == f(f(f(f(s, int_<1>), int_<2>), int_<3>), int_<4>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(int_<1>)) == f(s, int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>)) == f(f(s, int_<1>), int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>, int_<3>)) == f(f(f(s, int_<1>), int_<2>), int_<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, foldable(int_<1>, int_<2>, int_<3>, int_<4>)) == f(f(f(f(s, int_<1>), int_<2>), int_<3>), int_<4>));
 }
 
 int main() {
diff --git a/test/foldable/foldl1.cpp b/test/foldable/foldl1.cpp
index 8471798d1..bf5a7fb47 100644
--- a/test/foldable/foldl1.cpp
+++ b/test/foldable/foldl1.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -25,18 +25,18 @@ void test() {
 
     {
     constexpr auto s = std::make_tuple(1);
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s)) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, '2')) == f(s, '2'));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, '2', 3.3)) == f(f(s, '2'), 3.3));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, '2', 3.3, 4.4f)) == f(f(f(s, '2'), 3.3), 4.4f));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s)) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, '2')) == f(s, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, '2', 3.3)) == f(f(s, '2'), 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, '2', 3.3, 4.4f)) == f(f(f(s, '2'), 3.3), 4.4f));
     }
 
     {
     constexpr auto s = std::make_tuple(int_<1>);
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s)) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, int_<2>)) == f(s, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, int_<2>, int_<3>)) == f(f(s, int_<2>), int_<3>));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, foldable(s, int_<2>, int_<3>, int_<4>)) == f(f(f(s, int_<2>), int_<3>), int_<4>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s)) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, int_<2>)) == f(s, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, int_<2>, int_<3>)) == f(f(s, int_<2>), int_<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, foldable(s, int_<2>, int_<3>, int_<4>)) == f(f(f(s, int_<2>), int_<3>), int_<4>));
     }
 }
 
diff --git a/test/foldable/foldr.cpp b/test/foldable/foldr.cpp
index dea392a81..8396bd396 100644
--- a/test/foldable/foldr.cpp
+++ b/test/foldable/foldr.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -24,16 +24,16 @@ void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
     constexpr std::tuple<> s;
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable()) == s);
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(1)) == f(1, s));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(1, '2')) == f(1, f('2', s)));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(1, '2', 3.3)) == f(1, f('2', f(3.3, s))));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(1, '2', 3.3, 4.4f)) == f(1, f('2', f(3.3, f(4.4f, s)))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable()) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(1)) == f(1, s));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(1, '2')) == f(1, f('2', s)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(1, '2', 3.3)) == f(1, f('2', f(3.3, s))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(1, '2', 3.3, 4.4f)) == f(1, f('2', f(3.3, f(4.4f, s)))));
 
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(int_<0>)) == f(int_<0>, s));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>)) == f(int_<0>, f(int_<1>, s)));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>, int_<2>)) == f(int_<0>, f(int_<1>, f(int_<2>, s))));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == f(int_<0>, f(int_<1>, f(int_<2>, f(int_<3>, s)))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(int_<0>)) == f(int_<0>, s));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>)) == f(int_<0>, f(int_<1>, s)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>, int_<2>)) == f(int_<0>, f(int_<1>, f(int_<2>, s))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == f(int_<0>, f(int_<1>, f(int_<2>, f(int_<3>, s)))));
 }
 
 int main() {
diff --git a/test/foldable/foldr1.cpp b/test/foldable/foldr1.cpp
index b6c10dfd8..05185b07d 100644
--- a/test/foldable/foldr1.cpp
+++ b/test/foldable/foldr1.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -27,15 +27,15 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(tup(1))) == tup(1));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(1, tup('2'))) == f(1, tup('2')));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(1, '2', tup(3.3))) == f(1, f('2', tup(3.3))));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(1, '2', 3.3, tup(4.4f))) == f(1, f('2', f(3.3, tup(4.4f)))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(tup(1))) == tup(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(1, tup('2'))) == f(1, tup('2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(1, '2', tup(3.3))) == f(1, f('2', tup(3.3))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(1, '2', 3.3, tup(4.4f))) == f(1, f('2', f(3.3, tup(4.4f)))));
 
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(tup(int_<1>))) == tup(int_<1>));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(int_<1>, tup(int_<2>))) == f(int_<1>, tup(int_<2>)));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(int_<1>, int_<2>, tup(int_<3>))) == f(int_<1>, f(int_<2>, tup(int_<3>))));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, foldable(int_<1>, int_<2>, int_<3>, tup(int_<4>))) == f(int_<1>, f(int_<2>, f(int_<3>, tup(int_<4>)))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(tup(int_<1>))) == tup(int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(int_<1>, tup(int_<2>))) == f(int_<1>, tup(int_<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(int_<1>, int_<2>, tup(int_<3>))) == f(int_<1>, f(int_<2>, tup(int_<3>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, foldable(int_<1>, int_<2>, int_<3>, tup(int_<4>))) == f(int_<1>, f(int_<2>, f(int_<3>, tup(int_<4>)))));
 }
 
 int main() {
diff --git a/test/foldable/length.cpp b/test/foldable/length.cpp
index 4f17b1386..ea73a7964 100644
--- a/test/foldable/length.cpp
+++ b/test/foldable/length.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,17 +16,17 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(length(foldable()) == size_t<0>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(1)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(1, '2')) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(1, '2', 3.3)) == size_t<3>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(1, '2', 3.3, 4.4f)) == size_t<4>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(1, '2', 3.3, 4.4f, nullptr)) == size_t<5>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable()) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(1)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(1, '2')) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(1, '2', 3.3)) == size_t<3>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(1, '2', 3.3, 4.4f)) == size_t<4>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(1, '2', 3.3, 4.4f, nullptr)) == size_t<5>);
 
-    BOOST_HANA_STATIC_ASSERT(length(foldable()) == size_t<0>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(int_<0>)) == size_t<1>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(int_<0>, int_<1>)) == size_t<2>);
-    BOOST_HANA_STATIC_ASSERT(length(foldable(int_<0>, int_<1>, int_<2>)) == size_t<3>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable()) == size_t<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(int_<0>)) == size_t<1>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(int_<0>, int_<1>)) == size_t<2>);
+    BOOST_HANA_CONSTANT_ASSERT(length(foldable(int_<0>, int_<1>, int_<2>)) == size_t<3>);
 }
 
 int main() {
diff --git a/test/foldable/maximum.cpp b/test/foldable/maximum.cpp
index 834d17d6c..14bd88057 100644
--- a/test/foldable/maximum.cpp
+++ b/test/foldable/maximum.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,61 +16,58 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    // compile-time
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>, int_<1>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<0>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>, int_<1>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<0>)) == int_<1>);
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>, int_<1>, int_<2>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<0>, int_<2>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<0>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<2>, int_<1>, int_<0>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<2>, int_<0>, int_<1>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>, int_<1>, int_<2>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<0>, int_<2>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<0>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<2>, int_<1>, int_<0>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<2>, int_<0>, int_<1>)) == int_<2>);
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<0>, int_<2>, int_<3>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<0>, int_<3>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<3>, int_<0>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<2>, int_<1>, int_<3>, int_<0>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<2>, int_<3>, int_<1>, int_<0>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<2>, int_<3>, int_<0>, int_<1>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<3>, int_<2>, int_<0>, int_<1>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<3>, int_<0>, int_<2>, int_<1>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<3>, int_<0>, int_<1>, int_<2>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>, int_<2>, int_<3>, int_<1>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int_<0>, int_<3>, int_<1>, int_<2>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<0>, int_<2>, int_<3>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<0>, int_<3>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<1>, int_<2>, int_<3>, int_<0>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<2>, int_<1>, int_<3>, int_<0>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<2>, int_<3>, int_<1>, int_<0>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<2>, int_<3>, int_<0>, int_<1>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<3>, int_<2>, int_<0>, int_<1>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<3>, int_<0>, int_<2>, int_<1>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<3>, int_<0>, int_<1>, int_<2>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>, int_<2>, int_<3>, int_<1>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(maximum(foldable(int_<0>, int_<3>, int_<1>, int_<2>)) == int_<3>);
 
 
-    // constexpr/runtime
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0})) == int{0});
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{1})) == char{1});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{0})) == int{1});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{1})) == char{1});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{0})) == int{1});
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{1}, long{2})) == long{2});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{0}, long{2})) == long{2});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{2}, long{0})) == char{2});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{2}, char{1}, long{0})) == int{2});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{2}, char{0}, long{1})) == int{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{1}, long{2})) == long{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{0}, long{2})) == long{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{2}, long{0})) == char{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{2}, char{1}, long{0})) == int{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{2}, char{0}, long{1})) == int{2});
 
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{1}, long{2}, double{3})) == double{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{0}, long{2}, double{3})) == double{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{2}, long{0}, double{3})) == double{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{1}, char{2}, long{3}, double{0})) == long{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{2}, char{1}, long{3}, double{0})) == long{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{2}, char{3}, long{1}, double{0})) == char{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{2}, char{3}, long{0}, double{1})) == char{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{3}, char{2}, long{0}, double{1})) == int{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{3}, char{0}, long{2}, double{1})) == int{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{3}, char{0}, long{1}, double{2})) == int{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{2}, long{3}, double{1})) == long{3});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{3}, long{1}, double{2})) == char{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{1}, long{2}, double{3})) == double{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{0}, long{2}, double{3})) == double{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{2}, long{0}, double{3})) == double{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{1}, char{2}, long{3}, double{0})) == long{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{2}, char{1}, long{3}, double{0})) == long{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{2}, char{3}, long{1}, double{0})) == char{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{2}, char{3}, long{0}, double{1})) == char{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{3}, char{2}, long{0}, double{1})) == int{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{3}, char{0}, long{2}, double{1})) == int{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{3}, char{0}, long{1}, double{2})) == int{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{2}, long{3}, double{1})) == long{3});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{3}, long{1}, double{2})) == char{3});
 
 
-    // mixed
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, char{1}, long_<2>)) == long{2});
-    BOOST_HANA_STATIC_ASSERT(maximum(foldable(int{0}, long_<1>, char{2})) == char{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, char{1}, long_<2>)) == long{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(maximum(foldable(int{0}, long_<1>, char{2})) == char{2});
 }
 
 int main() {
diff --git a/test/foldable/minimum.cpp b/test/foldable/minimum.cpp
index abe5827bb..4ccc21ab5 100644
--- a/test/foldable/minimum.cpp
+++ b/test/foldable/minimum.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,61 +16,58 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    // compile-time
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<0>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, int_<1>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<0>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<2>, int_<1>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<2>, int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>, int_<1>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<0>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<2>, int_<1>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<2>, int_<0>, int_<1>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<0>, int_<2>, int_<3>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<0>, int_<3>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<3>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<2>, int_<1>, int_<3>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<2>, int_<3>, int_<1>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<2>, int_<3>, int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<3>, int_<2>, int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<3>, int_<0>, int_<2>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<3>, int_<0>, int_<1>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, int_<2>, int_<3>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, int_<3>, int_<1>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<0>, int_<2>, int_<3>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<0>, int_<3>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<1>, int_<2>, int_<3>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<2>, int_<1>, int_<3>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<2>, int_<3>, int_<1>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<2>, int_<3>, int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<3>, int_<2>, int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<3>, int_<0>, int_<2>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<3>, int_<0>, int_<1>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>, int_<2>, int_<3>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(minimum(foldable(int_<0>, int_<3>, int_<1>, int_<2>)) == int_<0>);
 
 
-    // constexpr/runtime
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0})) == int{0});
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{1})) == int{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{0})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{1})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{0})) == char{0});
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{1}, long{2})) == int{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{0}, long{2})) == char{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{2}, long{0})) == long{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{2}, char{1}, long{0})) == long{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{2}, char{0}, long{1})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{1}, long{2})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{0}, long{2})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{2}, long{0})) == long{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{2}, char{1}, long{0})) == long{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{2}, char{0}, long{1})) == char{0});
 
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{1}, long{2}, double{3})) == int{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{0}, long{2}, double{3})) == char{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{2}, long{0}, double{3})) == long{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{1}, char{2}, long{3}, double{0})) == double{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{2}, char{1}, long{3}, double{0})) == double{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{2}, char{3}, long{1}, double{0})) == double{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{2}, char{3}, long{0}, double{1})) == long{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{3}, char{2}, long{0}, double{1})) == long{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{3}, char{0}, long{2}, double{1})) == char{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{3}, char{0}, long{1}, double{2})) == char{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{2}, long{3}, double{1})) == int{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{3}, long{1}, double{2})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{1}, long{2}, double{3})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{0}, long{2}, double{3})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{2}, long{0}, double{3})) == long{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{1}, char{2}, long{3}, double{0})) == double{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{2}, char{1}, long{3}, double{0})) == double{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{2}, char{3}, long{1}, double{0})) == double{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{2}, char{3}, long{0}, double{1})) == long{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{3}, char{2}, long{0}, double{1})) == long{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{3}, char{0}, long{2}, double{1})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{3}, char{0}, long{1}, double{2})) == char{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{2}, long{3}, double{1})) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{3}, long{1}, double{2})) == int{0});
 
 
-    // mixed
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int{0}, char{1}, long_<2>)) == int{0});
-    BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>, char{1}, long{2})) == int_<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int{0}, char{1}, long_<2>)) == int{0});
+    BOOST_HANA_CONSTEXPR_ASSERT(minimum(foldable(int_<0>, char{1}, long{2})) == int_<0>);
 }
 
 int main() {
diff --git a/test/foldable/product.cpp b/test/foldable/product.cpp
index c1671a389..0322bf416 100644
--- a/test/foldable/product.cpp
+++ b/test/foldable/product.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,16 +16,16 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(product(foldable()) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(int_<2>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(int_<2>, int_<3>)) == int_<2 * 3>);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(int_<2>, int_<3>, int_<4>)) == int_<2 * 3 * 4>);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(int_<2>, int_<3>, int_<4>, int_<5>)) == int_<2 * 3 * 4 * 5>);
+    BOOST_HANA_CONSTANT_ASSERT(product(foldable()) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(product(foldable(int_<2>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(product(foldable(int_<2>, int_<3>)) == int_<2 * 3>);
+    BOOST_HANA_CONSTANT_ASSERT(product(foldable(int_<2>, int_<3>, int_<4>)) == int_<2 * 3 * 4>);
+    BOOST_HANA_CONSTANT_ASSERT(product(foldable(int_<2>, int_<3>, int_<4>, int_<5>)) == int_<2 * 3 * 4 * 5>);
 
-    BOOST_HANA_STATIC_ASSERT(product(foldable(2)) == 2);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(2, 3)) == 2 * 3);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(2, 3, 4)) == 2 * 3 * 4);
-    BOOST_HANA_STATIC_ASSERT(product(foldable(2, 3, 4, 5)) == 2 * 3 * 4 * 5);
+    BOOST_HANA_CONSTEXPR_ASSERT(product(foldable(2)) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(product(foldable(2, 3)) == 2 * 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(product(foldable(2, 3, 4)) == 2 * 3 * 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(product(foldable(2, 3, 4, 5)) == 2 * 3 * 4 * 5);
 }
 
 int main() {
diff --git a/test/foldable/sum.cpp b/test/foldable/sum.cpp
index 555d84390..c396d2d6f 100644
--- a/test/foldable/sum.cpp
+++ b/test/foldable/sum.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,16 +16,16 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(sum(foldable()) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(int_<1>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(int_<1>, int_<2>)) == int_<1 + 2>);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(int_<1>, int_<2>, int_<3>)) == int_<1 + 2 + 3>);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(int_<1>, int_<2>, int_<3>, int_<4>)) == int_<1 + 2 + 3 + 4>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(foldable()) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(foldable(int_<1>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(foldable(int_<1>, int_<2>)) == int_<1 + 2>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(foldable(int_<1>, int_<2>, int_<3>)) == int_<1 + 2 + 3>);
+    BOOST_HANA_CONSTANT_ASSERT(sum(foldable(int_<1>, int_<2>, int_<3>, int_<4>)) == int_<1 + 2 + 3 + 4>);
 
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(1)) == 1);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(1, 2)) == 1 + 2);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(1, 2, 3)) == 1 + 2 + 3);
-    BOOST_HANA_STATIC_ASSERT(sum(foldable(1, 2, 3, 4)) == 1 + 2 + 3 + 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(sum(foldable(1)) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(sum(foldable(1, 2)) == 1 + 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(sum(foldable(1, 2, 3)) == 1 + 2 + 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(sum(foldable(1, 2, 3, 4)) == 1 + 2 + 3 + 4);
 }
 
 int main() {
diff --git a/test/foldable/unpack.cpp b/test/foldable/unpack.cpp
index 122a9832b..fd98ee15f 100644
--- a/test/foldable/unpack.cpp
+++ b/test/foldable/unpack.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/foldable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -23,15 +23,15 @@ template <typename mcd>
 void test() {
     constexpr auto foldable = detail::minimal::foldable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable()) == f());
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(1)) == f(1));
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(1, '2')) == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(1, '2', 3.3)) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(1, '2', 3.3, nullptr)) == f(1, '2', 3.3, nullptr));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable()) == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(1)) == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(1, '2')) == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(1, '2', 3.3)) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(1, '2', 3.3, nullptr)) == f(1, '2', 3.3, nullptr));
 
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(int_<0>)) == f(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(int_<0>, int_<1>)) == f(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(unpack(f, foldable(int_<0>, int_<1>, int_<2>)) == f(int_<0>, int_<1>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(int_<0>)) == f(int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(int_<0>, int_<1>)) == f(int_<0>, int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, foldable(int_<0>, int_<1>, int_<2>)) == f(int_<0>, int_<1>, int_<2>));
 }
 
 int main() {
diff --git a/test/functional/always.cpp b/test/functional/always.cpp
index 80bdba963..a8340205f 100644
--- a/test/functional/always.cpp
+++ b/test/functional/always.cpp
@@ -6,17 +6,17 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct nonpod { virtual ~nonpod() { } };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(always('a')() == 'a');
-    BOOST_HANA_STATIC_ASSERT(always('a')(1) == 'a');
-    BOOST_HANA_STATIC_ASSERT(always('a')(1, '2') == 'a');
-    BOOST_HANA_STATIC_ASSERT(always('a')(1, '2', "3") == 'a');
-    BOOST_HANA_STATIC_ASSERT(always('a')(1, '2', "3", 4.4f) == 'a');
-    BOOST_HANA_STATIC_ASSERT(always('a')(1, '2', "3", 4.4f, nonpod{}) == 'a');
+    BOOST_HANA_CONSTEXPR_ASSERT(always('a')() == 'a');
+    BOOST_HANA_CONSTEXPR_ASSERT(always('a')(1) == 'a');
+    BOOST_HANA_CONSTEXPR_ASSERT(always('a')(1, '2') == 'a');
+    BOOST_HANA_CONSTEXPR_ASSERT(always('a')(1, '2', "3") == 'a');
+    BOOST_HANA_CONSTEXPR_ASSERT(always('a')(1, '2', "3", 4.4f) == 'a');
+    BOOST_HANA_RUNTIME_ASSERT(always('a')(1, '2', "3", 4.4f, nonpod{}) == 'a');
 }
diff --git a/test/functional/apply.cpp b/test/functional/apply.cpp
index 9c2f8a625..8da700934 100644
--- a/test/functional/apply.cpp
+++ b/test/functional/apply.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,10 +18,10 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...xs) {
 struct nonpod { virtual ~nonpod() { } };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(apply(f) == 0);
-    BOOST_HANA_STATIC_ASSERT(apply(f, 1) == 1);
-    BOOST_HANA_STATIC_ASSERT(apply(f, 1, '2') == 2);
-    BOOST_HANA_STATIC_ASSERT(apply(f, 1, '2', "3") == 3);
-    BOOST_HANA_STATIC_ASSERT(apply(f, 1, '2', "3", 4.4) == 4);
-    BOOST_HANA_STATIC_ASSERT(apply(f, 1, '2', "3", 4.4, nonpod{}) == 5);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(f) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(f, 1) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(f, 1, '2') == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(f, 1, '2', "3") == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(apply(f, 1, '2', "3", 4.4) == 4);
+    BOOST_HANA_RUNTIME_ASSERT(apply(f, 1, '2', "3", 4.4, nonpod{}) == 5);
 }
diff --git a/test/functional/arg.cpp b/test/functional/arg.cpp
index 2ccee2707..6f500f0fc 100644
--- a/test/functional/arg.cpp
+++ b/test/functional/arg.cpp
@@ -6,35 +6,35 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct nonpod { virtual ~nonpod() { } };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(arg<1>(1) == 1);
-    BOOST_HANA_STATIC_ASSERT(arg<1>(1, '2') == 1);
-    BOOST_HANA_STATIC_ASSERT(arg<1>(1, '2', 3.3) == 1);
-    BOOST_HANA_STATIC_ASSERT(arg<1>(1, '2', 3.3, nonpod{}) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<1>(1) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<1>(1, '2') == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<1>(1, '2', 3.3) == 1);
+    BOOST_HANA_RUNTIME_ASSERT(arg<1>(1, '2', 3.3, nonpod{}) == 1);
 
-    BOOST_HANA_STATIC_ASSERT(arg<2>(1, '2') == '2');
-    BOOST_HANA_STATIC_ASSERT(arg<2>(1, '2', 3.3) == '2');
-    BOOST_HANA_STATIC_ASSERT(arg<2>(1, '2', 3.3, 4.4f) == '2');
-    BOOST_HANA_STATIC_ASSERT(arg<2>(1, '2', 3.3, 4.4f, nonpod{}) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<2>(1, '2') == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<2>(1, '2', 3.3) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<2>(1, '2', 3.3, 4.4f) == '2');
+    BOOST_HANA_RUNTIME_ASSERT(arg<2>(1, '2', 3.3, 4.4f, nonpod{}) == '2');
 
-    BOOST_HANA_STATIC_ASSERT(arg<3>(1, '2', 3.3) == 3.3);
-    BOOST_HANA_STATIC_ASSERT(arg<3>(1, '2', 3.3, 4.4f) == 3.3);
-    BOOST_HANA_STATIC_ASSERT(arg<3>(1, '2', 3.3, 4.4f, nonpod{}) == 3.3);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<3>(1, '2', 3.3) == 3.3);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<3>(1, '2', 3.3, 4.4f) == 3.3);
+    BOOST_HANA_RUNTIME_ASSERT(arg<3>(1, '2', 3.3, 4.4f, nonpod{}) == 3.3);
 
-    BOOST_HANA_STATIC_ASSERT(arg<4>(1, '2', 3.3, 4.4f) == 4.4f);
-    BOOST_HANA_STATIC_ASSERT(arg<4>(1, '2', 3.3, 4.4f, nonpod{}) == 4.4f);
+    BOOST_HANA_CONSTEXPR_ASSERT(arg<4>(1, '2', 3.3, 4.4f) == 4.4f);
+    BOOST_HANA_RUNTIME_ASSERT(arg<4>(1, '2', 3.3, 4.4f, nonpod{}) == 4.4f);
 
     nonpod n = arg<5>(1, '2', 3.3, 4.4f, nonpod{});
     (void)n;
 
     // Check with non-pods before the index we're targetting.
-    BOOST_HANA_STATIC_ASSERT(arg<2>(nonpod{}, '2') == '2');
-    BOOST_HANA_STATIC_ASSERT(arg<3>(nonpod{}, '2', 3.3) == 3.3);
-    BOOST_HANA_STATIC_ASSERT(arg<4>(nonpod{}, '2', 3.3, 4.4f) == 4.4f);
+    BOOST_HANA_RUNTIME_ASSERT(arg<2>(nonpod{}, '2') == '2');
+    BOOST_HANA_RUNTIME_ASSERT(arg<3>(nonpod{}, '2', 3.3) == 3.3);
+    BOOST_HANA_RUNTIME_ASSERT(arg<4>(nonpod{}, '2', 3.3, 4.4f) == 4.4f);
 }
diff --git a/test/functional/compose.cpp b/test/functional/compose.cpp
index 329656c11..9d8691313 100644
--- a/test/functional/compose.cpp
+++ b/test/functional/compose.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -30,11 +30,11 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(compose(f, g)(x<0>) == f(g(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(compose(f, g)(x<0>, x<1>) == f(g(x<0>), x<1>));
-    BOOST_HANA_STATIC_ASSERT(compose(f, g)(x<0>, x<1>, x<2>) == f(g(x<0>), x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g)(x<0>) == f(g(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g)(x<0>, x<1>) == f(g(x<0>), x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g)(x<0>, x<1>, x<2>) == f(g(x<0>), x<1>, x<2>));
 
-    BOOST_HANA_STATIC_ASSERT(compose(f, g, h)(x<0>) == f(g(h(x<0>))));
-    BOOST_HANA_STATIC_ASSERT(compose(f, g, h)(x<0>, x<1>) == f(g(h(x<0>)), x<1>));
-    BOOST_HANA_STATIC_ASSERT(compose(f, g, h)(x<0>, x<1>, x<2>) == f(g(h(x<0>)), x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g, h)(x<0>) == f(g(h(x<0>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g, h)(x<0>, x<1>) == f(g(h(x<0>)), x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g, h)(x<0>, x<1>, x<2>) == f(g(h(x<0>)), x<1>, x<2>));
 }
diff --git a/test/functional/curry.cpp b/test/functional/curry.cpp
index edb0e3175..d4b83e967 100644
--- a/test/functional/curry.cpp
+++ b/test/functional/curry.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -16,31 +16,31 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...xs) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(curry<0>(f)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<0>(f)() == f());
 
-    BOOST_HANA_STATIC_ASSERT(curry<1>(f)(1) == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<1>(f)(1) == f(1));
 
-    BOOST_HANA_STATIC_ASSERT(curry<2>(f)(1)('2') == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(curry<2>(f)(1, '2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<2>(f)(1)('2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<2>(f)(1, '2') == f(1, '2'));
 
-    BOOST_HANA_STATIC_ASSERT(curry<3>(f)(1)('2')(3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(f)(1)('2', 3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(f)(1, '2')(3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(f)(1, '2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(f)(1)('2')(3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(f)(1)('2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(f)(1, '2')(3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(f)(1, '2', 3.3) == f(1, '2', 3.3));
 
 
     // Make sure curry is idempotent; this is important because it allows
     // currying a function in generic contexts where it is unknown whether
     // the function is already curried.
-    BOOST_HANA_STATIC_ASSERT(curry<0>(curry<0>(f))() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<0>(curry<0>(f))() == f());
 
-    BOOST_HANA_STATIC_ASSERT(curry<1>(curry<1>(f))(1) == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<1>(curry<1>(f))(1) == f(1));
 
-    BOOST_HANA_STATIC_ASSERT(curry<2>(curry<2>(f))(1)('2') == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(curry<2>(curry<2>(f))(1, '2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<2>(curry<2>(f))(1)('2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<2>(curry<2>(f))(1, '2') == f(1, '2'));
 
-    BOOST_HANA_STATIC_ASSERT(curry<3>(curry<3>(f))(1)('2')(3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(curry<3>(f))(1)('2', 3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(curry<3>(f))(1, '2')(3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(curry<3>(curry<3>(f))(1, '2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(curry<3>(f))(1)('2')(3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(curry<3>(f))(1)('2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(curry<3>(f))(1, '2')(3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(curry<3>(curry<3>(f))(1, '2', 3.3) == f(1, '2', 3.3));
 }
diff --git a/test/functional/demux.cpp b/test/functional/demux.cpp
index f38baa030..cdd99da3f 100644
--- a/test/functional/demux.cpp
+++ b/test/functional/demux.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -21,13 +21,13 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = f;
 BOOST_HANA_CONSTEXPR_LAMBDA auto h = f;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(demux(f)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f)() == f());
 
-    BOOST_HANA_STATIC_ASSERT(demux(f, g)(1) == f(g(1)));
-    BOOST_HANA_STATIC_ASSERT(demux(f, g)(1, '2') == f(g(1, '2')));
-    BOOST_HANA_STATIC_ASSERT(demux(f, g)(1, '2', 3.3) == f(g(1, '2', 3.3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g)(1) == f(g(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g)(1, '2') == f(g(1, '2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g)(1, '2', 3.3) == f(g(1, '2', 3.3)));
 
-    BOOST_HANA_STATIC_ASSERT(demux(f, g, h)(1) == f(g(1), h(1)));
-    BOOST_HANA_STATIC_ASSERT(demux(f, g, h)(1, '2') == f(g(1, '2'), h(1, '2')));
-    BOOST_HANA_STATIC_ASSERT(demux(f, g, h)(1, '2', 3.3) == f(g(1, '2', 3.3), h(1, '2', 3.3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g, h)(1) == f(g(1), h(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g, h)(1, '2') == f(g(1, '2'), h(1, '2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(demux(f, g, h)(1, '2', 3.3) == f(g(1, '2', 3.3), h(1, '2', 3.3)));
 }
diff --git a/test/functional/fix.cpp b/test/functional/fix.cpp
index 25f1eacdc..d29b58c27 100644
--- a/test/functional/fix.cpp
+++ b/test/functional/fix.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -26,7 +26,7 @@ constexpr unsigned long long reference(unsigned long long n)
 
 template <int n>
 constexpr void test() {
-    BOOST_HANA_STATIC_ASSERT(fact(ullong<n>) == ullong<reference(n)>);
+    BOOST_HANA_CONSTANT_ASSERT(fact(ullong<n>) == ullong<reference(n)>);
     test<n - 1>();
 }
 
diff --git a/test/functional/flip.cpp b/test/functional/flip.cpp
index 0128f1b02..d4e567bda 100644
--- a/test/functional/flip.cpp
+++ b/test/functional/flip.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,8 +18,8 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...xs) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(flip(f)(1, '2') == f('2', 1));
-    BOOST_HANA_STATIC_ASSERT(flip(f)(1, '2', 3.3) == f('2', 1, 3.3));
-    BOOST_HANA_STATIC_ASSERT(flip(f)(1, '2', 3.3, 4.4f) == f('2', 1, 3.3, 4.4f));
-    BOOST_HANA_STATIC_ASSERT(flip(f)(1, '2', 3.3, 4.4f, nullptr) == f('2', 1, 3.3, 4.4f, nullptr));
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(f)(1, '2') == f('2', 1));
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(f)(1, '2', 3.3) == f('2', 1, 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(f)(1, '2', 3.3, 4.4f) == f('2', 1, 3.3, 4.4f));
+    BOOST_HANA_CONSTEXPR_ASSERT(flip(f)(1, '2', 3.3, 4.4f, nullptr) == f('2', 1, 3.3, 4.4f, nullptr));
 }
diff --git a/test/functional/id.cpp b/test/functional/id.cpp
index 4de6a5322..6c117ca84 100644
--- a/test/functional/id.cpp
+++ b/test/functional/id.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(id(0) == 0);
-    BOOST_HANA_STATIC_ASSERT(id('1') == '1');
-    BOOST_HANA_STATIC_ASSERT(id(2.2) == 2.2);
-    BOOST_HANA_STATIC_ASSERT(id(3.3f) == 3.3f);
+    BOOST_HANA_CONSTEXPR_ASSERT(id(0) == 0);
+    BOOST_HANA_CONSTEXPR_ASSERT(id('1') == '1');
+    BOOST_HANA_CONSTEXPR_ASSERT(id(2.2) == 2.2);
+    BOOST_HANA_CONSTEXPR_ASSERT(id(3.3f) == 3.3f);
 }
diff --git a/test/functional/lockstep.cpp b/test/functional/lockstep.cpp
index 335b0fbca..983b8a6e1 100644
--- a/test/functional/lockstep.cpp
+++ b/test/functional/lockstep.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -22,8 +22,8 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto h = g;
 BOOST_HANA_CONSTEXPR_LAMBDA auto i = g;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lockstep(f)() == f());
-    BOOST_HANA_STATIC_ASSERT(lockstep(f, g)(1) == f(g(1)));
-    BOOST_HANA_STATIC_ASSERT(lockstep(f, g, h)(1, '2') == f(g(1), h('2')));
-    BOOST_HANA_STATIC_ASSERT(lockstep(f, g, h, i)(1, '2', 3.3) == f(g(1), h('2'), i(3.3)));
+    BOOST_HANA_CONSTEXPR_ASSERT(lockstep(f)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(lockstep(f, g)(1) == f(g(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(lockstep(f, g, h)(1, '2') == f(g(1), h('2')));
+    BOOST_HANA_CONSTEXPR_ASSERT(lockstep(f, g, h, i)(1, '2', 3.3) == f(g(1), h('2'), i(3.3)));
 }
diff --git a/test/functional/on.cpp b/test/functional/on.cpp
index 689ddd714..19d47e4a1 100644
--- a/test/functional/on.cpp
+++ b/test/functional/on.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -26,16 +26,16 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(on(f, g)() == f());
-    BOOST_HANA_STATIC_ASSERT(on(f, g)(x<0>) == f(g(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(on(f, g)(x<0>, x<1>) == f(g(x<0>), g(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(on(f, g)(x<0>, x<1>, x<2>) == f(g(x<0>), g(x<1>), g(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(on(f, g)(x<0>, x<1>, x<2>, x<3>) == f(g(x<0>), g(x<1>), g(x<2>), g(x<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(on(f, g)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(on(f, g)(x<0>) == f(g(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(on(f, g)(x<0>, x<1>) == f(g(x<0>), g(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(on(f, g)(x<0>, x<1>, x<2>) == f(g(x<0>), g(x<1>), g(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(on(f, g)(x<0>, x<1>, x<2>, x<3>) == f(g(x<0>), g(x<1>), g(x<2>), g(x<3>)));
 
     // check the infix version
-    BOOST_HANA_STATIC_ASSERT((f /on/ g)() == f());
-    BOOST_HANA_STATIC_ASSERT((f /on/ g)(x<0>) == f(g(x<0>)));
-    BOOST_HANA_STATIC_ASSERT((f /on/ g)(x<0>, x<1>) == f(g(x<0>), g(x<1>)));
-    BOOST_HANA_STATIC_ASSERT((f /on/ g)(x<0>, x<1>, x<2>) == f(g(x<0>), g(x<1>), g(x<2>)));
-    BOOST_HANA_STATIC_ASSERT((f /on/ g)(x<0>, x<1>, x<2>, x<3>) == f(g(x<0>), g(x<1>), g(x<2>), g(x<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT((f /on/ g)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT((f /on/ g)(x<0>) == f(g(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT((f /on/ g)(x<0>, x<1>) == f(g(x<0>), g(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT((f /on/ g)(x<0>, x<1>, x<2>) == f(g(x<0>), g(x<1>), g(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT((f /on/ g)(x<0>, x<1>, x<2>, x<3>) == f(g(x<0>), g(x<1>), g(x<2>), g(x<3>)));
 }
diff --git a/test/functional/partial.cpp b/test/functional/partial.cpp
index f6007d5f7..1c6c4352f 100644
--- a/test/functional/partial.cpp
+++ b/test/functional/partial.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,18 +18,18 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...xs) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(partial(f)() == f());
-    BOOST_HANA_STATIC_ASSERT(partial(f)(1) == f(1));
-    BOOST_HANA_STATIC_ASSERT(partial(f)(1, '2') == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(partial(f)(1, '2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f)() == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f)(1) == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f)(1, '2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f)(1, '2', 3.3) == f(1, '2', 3.3));
 
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1)() == f(1));
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1)('2') == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1)('2', 3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1)() == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1)('2') == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1)('2', 3.3) == f(1, '2', 3.3));
 
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1, '2')() == f(1, '2'));
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1, '2')(3.3) == f(1, '2', 3.3));
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1, '2')(3.3, 4.4f) == f(1, '2', 3.3, 4.4f));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1, '2')() == f(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1, '2')(3.3) == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1, '2')(3.3, 4.4f) == f(1, '2', 3.3, 4.4f));
 
-    BOOST_HANA_STATIC_ASSERT(partial(f, 1, '2', 3.3)() == f(1, '2', 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(partial(f, 1, '2', 3.3)() == f(1, '2', 3.3));
 }
diff --git a/test/functional/placeholder.cpp b/test/functional/placeholder.cpp
index b33abb061..9762f4951 100644
--- a/test/functional/placeholder.cpp
+++ b/test/functional/placeholder.cpp
@@ -6,10 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/functional.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
-
-#include <cassert>
 using namespace boost::hana;
 
 
@@ -17,23 +15,23 @@ struct _extra { virtual ~_extra() { } };
 _extra extra{};
 
 #define BOOST_HANA_TEST_BINARY_OP(op, x, y)                                 \
-    BOOST_HANA_STATIC_ASSERT((_ op _)(x, y) == (x op y));                   \
-    assert((_ op _)(x, y, extra) == (x op y));                              \
-    assert((_ op _)(x, y, extra, extra) == (x op y));                       \
+    BOOST_HANA_CONSTEXPR_ASSERT((_ op _)(x, y) == (x op y));                \
+    BOOST_HANA_RUNTIME_ASSERT((_ op _)(x, y, extra) == (x op y));           \
+    BOOST_HANA_RUNTIME_ASSERT((_ op _)(x, y, extra, extra) == (x op y));    \
                                                                             \
-    BOOST_HANA_STATIC_ASSERT((_ op y)(x) == (x op y));                      \
-    assert((_ op y)(x, extra) == (x op y));                                 \
-    assert((_ op y)(x, extra, extra) == (x op y));                          \
+    BOOST_HANA_CONSTEXPR_ASSERT((_ op y)(x) == (x op y));                   \
+    BOOST_HANA_RUNTIME_ASSERT((_ op y)(x, extra) == (x op y));              \
+    BOOST_HANA_RUNTIME_ASSERT((_ op y)(x, extra, extra) == (x op y));       \
                                                                             \
-    BOOST_HANA_STATIC_ASSERT((x op _)(y) == (x op y));                      \
-    assert((x op _)(y, extra) == (x op y));                                 \
-    assert((x op _)(y, extra, extra) == (x op y));                          \
+    BOOST_HANA_CONSTEXPR_ASSERT((x op _)(y) == (x op y));                   \
+    BOOST_HANA_RUNTIME_ASSERT((x op _)(y, extra) == (x op y));              \
+    BOOST_HANA_RUNTIME_ASSERT((x op _)(y, extra, extra) == (x op y));       \
 /**/
 
 #define BOOST_HANA_TEST_UNARY_OP(op, x)                                     \
-    BOOST_HANA_STATIC_ASSERT((op _)(x) == (op x));                          \
-    assert((op _)(x, extra) == (op x));                                     \
-    assert((op _)(x, extra, extra) == (op x));                              \
+    BOOST_HANA_CONSTEXPR_ASSERT((op _)(x) == (op x));                       \
+    BOOST_HANA_RUNTIME_ASSERT((op _)(x, extra) == (op x));                  \
+    BOOST_HANA_RUNTIME_ASSERT((op _)(x, extra, extra) == (op x));           \
 /**/
 
 int main() {
@@ -72,18 +70,18 @@ int main() {
     constexpr int array[] = {0, 1, 2};
     BOOST_HANA_TEST_UNARY_OP(*, &i)
 
-    BOOST_HANA_STATIC_ASSERT(_[0](array) == array[0]);
-    assert(_[0](array, extra) == array[0]);
-    assert(_[0](array, extra, extra) == array[0]);
-    BOOST_HANA_STATIC_ASSERT(_[1](array) == array[1]);
-    BOOST_HANA_STATIC_ASSERT(_[1](array) == array[1]);
-    BOOST_HANA_STATIC_ASSERT(_[2](array) == array[2]);
+    BOOST_HANA_CONSTEXPR_ASSERT(_[0](array) == array[0]);
+    BOOST_HANA_RUNTIME_ASSERT(_[0](array, extra) == array[0]);
+    BOOST_HANA_RUNTIME_ASSERT(_[0](array, extra, extra) == array[0]);
+    BOOST_HANA_CONSTEXPR_ASSERT(_[1](array) == array[1]);
+    BOOST_HANA_CONSTEXPR_ASSERT(_[1](array) == array[1]);
+    BOOST_HANA_CONSTEXPR_ASSERT(_[2](array) == array[2]);
 
     // Other
     BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) { return x + 1; };
-    BOOST_HANA_STATIC_ASSERT(_(1)(f) == f(1));
-    assert(_(1)(f, extra) == f(1));
-    assert(_(1)(f, extra, extra) == f(1));
-    BOOST_HANA_STATIC_ASSERT(_(2)(f) == f(2));
-    BOOST_HANA_STATIC_ASSERT(_(3)(f) == f(3));
+    BOOST_HANA_CONSTEXPR_ASSERT(_(1)(f) == f(1));
+    BOOST_HANA_RUNTIME_ASSERT(_(1)(f, extra) == f(1));
+    BOOST_HANA_RUNTIME_ASSERT(_(1)(f, extra, extra) == f(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(_(2)(f) == f(2));
+    BOOST_HANA_CONSTEXPR_ASSERT(_(3)(f) == f(3));
 }
diff --git a/test/functor/adjust.cpp b/test/functor/adjust.cpp
index 9a3ffbf36..0c9edce9b 100644
--- a/test/functor/adjust.cpp
+++ b/test/functor/adjust.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functor/adjust_mcd.hpp>
 #include <boost/hana/functor/fmap_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/functor.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,8 +21,8 @@ template <typename mcd>
 void test() {
     constexpr auto functor = detail::minimal::functor<mcd>;
     constexpr auto x = 1;
-    BOOST_HANA_STATIC_ASSERT(adjust([](auto) { return true; }, f, functor(x)) == functor(f(x)));
-    BOOST_HANA_STATIC_ASSERT(adjust([](auto) { return false; }, f, functor(x)) == functor(x));
+    BOOST_HANA_CONSTEXPR_ASSERT(adjust([](auto) { return true; }, f, functor(x)) == functor(f(x)));
+    BOOST_HANA_CONSTEXPR_ASSERT(adjust([](auto) { return false; }, f, functor(x)) == functor(x));
 }
 
 int main() {
diff --git a/test/functor/fill.cpp b/test/functor/fill.cpp
index 79719934b..43f6e3a2f 100644
--- a/test/functor/fill.cpp
+++ b/test/functor/fill.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functor/adjust_mcd.hpp>
 #include <boost/hana/functor/fmap_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/functor.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -17,7 +17,7 @@ void test() {
     constexpr auto functor = detail::minimal::functor<mcd>;
     constexpr auto x = 1;
     constexpr auto y = 2.2;
-    BOOST_HANA_STATIC_ASSERT(fill(y, functor(x)) == functor(y));
+    BOOST_HANA_CONSTEXPR_ASSERT(fill(y, functor(x)) == functor(y));
 }
 
 int main() {
diff --git a/test/functor/fmap.cpp b/test/functor/fmap.cpp
index 0259229a9..53ca2484f 100644
--- a/test/functor/fmap.cpp
+++ b/test/functor/fmap.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functor/adjust_mcd.hpp>
 #include <boost/hana/functor/fmap_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/functor.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,7 +21,7 @@ template <typename mcd>
 void test() {
     constexpr auto functor = detail::minimal::functor<mcd>;
     constexpr auto x = 1;
-    BOOST_HANA_STATIC_ASSERT(fmap(f, functor(x)) == functor(f(x)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, functor(x)) == functor(f(x)));
 }
 
 int main() {
diff --git a/test/functor/laws.cpp b/test/functor/laws.cpp
index 82df1fdd8..cf3c01c98 100644
--- a/test/functor/laws.cpp
+++ b/test/functor/laws.cpp
@@ -8,9 +8,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functor/fmap_mcd.hpp>
 #include <boost/hana/functor/laws.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/functor.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 
@@ -33,7 +33,7 @@ template <typename mcd>
 void test() {
     constexpr auto functor = detail::minimal::functor<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(functor(x<0>)),
         list(f),
         list(g)
diff --git a/test/functor/replace.cpp b/test/functor/replace.cpp
index 2972b0673..dee7ddcbd 100644
--- a/test/functor/replace.cpp
+++ b/test/functor/replace.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functor/adjust_mcd.hpp>
 #include <boost/hana/functor/fmap_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/functor.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -17,8 +17,8 @@ void test() {
     constexpr auto functor = detail::minimal::functor<mcd>;
     constexpr auto x = 1;
     constexpr auto y = 2.2;
-    BOOST_HANA_STATIC_ASSERT(replace([](auto) { return true; }, y, functor(x)) == functor(y));
-    BOOST_HANA_STATIC_ASSERT(replace([](auto) { return false; }, y, functor(x)) == functor(x));
+    BOOST_HANA_CONSTEXPR_ASSERT(replace([](auto) { return true; }, y, functor(x)) == functor(y));
+    BOOST_HANA_CONSTEXPR_ASSERT(replace([](auto) { return false; }, y, functor(x)) == functor(x));
 }
 
 int main() {
diff --git a/test/integer_list/iterable/head.cpp b/test/integer_list/iterable/head.cpp
index 58fff936c..d3c4d9626 100644
--- a/test/integer_list/iterable/head.cpp
+++ b/test/integer_list/iterable/head.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integer_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(head(integer_list<int, 0>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(integer_list<int, 0, 1>) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(integer_list<int, 0, 1, 2>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(integer_list<int, 0>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(integer_list<int, 0, 1>) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(integer_list<int, 0, 1, 2>) == int_<0>);
 }
diff --git a/test/integer_list/iterable/is_empty.cpp b/test/integer_list/iterable/is_empty.cpp
index a107bec12..bb54bc2ef 100644
--- a/test/integer_list/iterable/is_empty.cpp
+++ b/test/integer_list/iterable/is_empty.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integer_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(integer_list<int>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(integer_list<int, 0>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(integer_list<int, 0, 1>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(integer_list<int, 0, 1, 2>));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(integer_list<int>));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(integer_list<int, 0>));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(integer_list<int, 0, 1>));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(integer_list<int, 0, 1, 2>));
 }
diff --git a/test/integer_list/iterable/tail.cpp b/test/integer_list/iterable/tail.cpp
index 7feb39bd8..8018201db 100644
--- a/test/integer_list/iterable/tail.cpp
+++ b/test/integer_list/iterable/tail.cpp
@@ -6,12 +6,12 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integer_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(tail(integer_list<int, 0>) == integer_list<int>);
-    BOOST_HANA_STATIC_ASSERT(tail(integer_list<int, 0, 1>) == integer_list<int, 1>);
-    BOOST_HANA_STATIC_ASSERT(tail(integer_list<int, 0, 1, 2>) == integer_list<int, 1, 2>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(integer_list<int, 0>) == integer_list<int>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(integer_list<int, 0, 1>) == integer_list<int, 1>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(integer_list<int, 0, 1, 2>) == integer_list<int, 1, 2>);
 }
diff --git a/test/integer_list/list/cons.cpp b/test/integer_list/list/cons.cpp
index f76347563..05d587b2f 100644
--- a/test/integer_list/list/cons.cpp
+++ b/test/integer_list/list/cons.cpp
@@ -6,17 +6,17 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integer_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(cons(integral<T, 0>, integer_list<U>) == integer_list<U, 0>);
-    BOOST_HANA_STATIC_ASSERT(cons(integral<T, 0>, integer_list<U, 1>) == integer_list<U, 0, 1>);
-    BOOST_HANA_STATIC_ASSERT(cons(integral<T, 0>, integer_list<U, 1, 2>) == integer_list<U, 0, 1, 2>);
-    BOOST_HANA_STATIC_ASSERT(cons(integral<T, 0>, integer_list<U, 1, 2, 3>) == integer_list<U, 0, 1, 2, 3>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(integral<T, 0>, integer_list<U>) == integer_list<U, 0>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(integral<T, 0>, integer_list<U, 1>) == integer_list<U, 0, 1>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(integral<T, 0>, integer_list<U, 1, 2>) == integer_list<U, 0, 1, 2>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(integral<T, 0>, integer_list<U, 1, 2, 3>) == integer_list<U, 0, 1, 2, 3>);
 }
 
 int main() {
diff --git a/test/integer_list/list/nil.cpp b/test/integer_list/list/nil.cpp
index 5d0626200..b023cfee7 100644
--- a/test/integer_list/list/nil.cpp
+++ b/test/integer_list/list/nil.cpp
@@ -6,12 +6,12 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integer_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(nil<IntegerList> == integer_list<int>);
-    BOOST_HANA_STATIC_ASSERT(nil<IntegerList> == integer_list<void>);
-    BOOST_HANA_STATIC_ASSERT(nil<IntegerList> == integer_list<char>);
+    BOOST_HANA_CONSTANT_ASSERT(nil<IntegerList> == integer_list<int>);
+    BOOST_HANA_CONSTANT_ASSERT(nil<IntegerList> == integer_list<void>);
+    BOOST_HANA_CONSTANT_ASSERT(nil<IntegerList> == integer_list<char>);
 }
diff --git a/test/integral/api.cpp b/test/integral/api.cpp
index eab23e3d1..46484cd00 100644
--- a/test/integral/api.cpp
+++ b/test/integral/api.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <cstddef>
@@ -14,32 +14,32 @@ Distributed under the Boost Software License, Version 1.0.
 using namespace boost::hana;
 
 
-int main() {
-    // operator()
-    static_assert(size_t<0>() == 0, "");
-    static_assert(size_t<1>() == 1, "");
-    static_assert(int_<-3>() == -3, "");
+// operator()
+static_assert(size_t<0>() == 0, "");
+static_assert(size_t<1>() == 1, "");
+static_assert(int_<-3>() == -3, "");
 
-    // decltype(operator())
-    BOOST_HANA_STATIC_ASSERT(decltype_(size_t<0>()) == type<std::size_t>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(int_<-3>()) == type<int>);
+// decltype(operator())
+BOOST_HANA_CONSTANT_ASSERT(decltype_(size_t<0>()) == type<std::size_t>);
+BOOST_HANA_CONSTANT_ASSERT(decltype_(int_<-3>()) == type<int>);
 
-    // conversions
-    constexpr std::size_t a = size_t<0>, b = size_t<1>;
-    static_assert(a == 0 && b == 1, "");
+// conversions
+constexpr std::size_t a = size_t<0>, b = size_t<1>;
+static_assert(a == 0 && b == 1, "");
 
-    constexpr int c = int_<0>, d = int_<-3>;
-    static_assert(c == 0 && d == -3, "");
+constexpr int c = int_<0>, d = int_<-3>;
+static_assert(c == 0 && d == -3, "");
 
-    // nested ::value
-    static_assert(decltype(int_<1>)::value == 1, "");
+// nested ::value
+static_assert(decltype(int_<1>)::value == 1, "");
 
-    // nested ::type
-    static_assert(std::is_same<
-        decltype(int_<1>)::type,
-        std::remove_cv_t<decltype(int_<1>)>
-    >{}, "");
+// nested ::type
+static_assert(std::is_same<
+    decltype(int_<1>)::type,
+    std::remove_cv_t<decltype(int_<1>)>
+>{}, "");
 
-    // nested ::value_type
-    static_assert(std::is_same<decltype(int_<1>)::value_type, int>{}, "");
-}
+// nested ::value_type
+static_assert(std::is_same<decltype(int_<1>)::value_type, int>{}, "");
+
+int main() { }
diff --git a/test/integral/bugs/strip_cv_qualifiers.cpp b/test/integral/bugs/strip_cv_qualifiers.cpp
index b32b5bd3f..218e7d4a5 100644
--- a/test/integral/bugs/strip_cv_qualifiers.cpp
+++ b/test/integral/bugs/strip_cv_qualifiers.cpp
@@ -6,16 +6,16 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
 
 template <typename T>
 constexpr void test_for() {
-    BOOST_HANA_STATIC_ASSERT(decltype_(integral<T const, 0>) == decltype_(integral<T, 0>));
-    BOOST_HANA_STATIC_ASSERT(decltype_(integral<T volatile, 0>) == decltype_(integral<T, 0>));
-    BOOST_HANA_STATIC_ASSERT(decltype_(integral<T const volatile, 0>) == decltype_(integral<T, 0>));
+    BOOST_HANA_CONSTANT_ASSERT(decltype_(integral<T const, 0>) == decltype_(integral<T, 0>));
+    BOOST_HANA_CONSTANT_ASSERT(decltype_(integral<T volatile, 0>) == decltype_(integral<T, 0>));
+    BOOST_HANA_CONSTANT_ASSERT(decltype_(integral<T const volatile, 0>) == decltype_(integral<T, 0>));
 }
 
 int main() {
diff --git a/test/integral/comparable/equal.cpp b/test/integral/comparable/equal.cpp
index 1734881ad..e958ace70 100644
--- a/test/integral/comparable/equal.cpp
+++ b/test/integral/comparable/equal.cpp
@@ -6,29 +6,29 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     // Integral == other
-    BOOST_HANA_STATIC_ASSERT(equal(int_<0>, int{0}));
-    BOOST_HANA_STATIC_ASSERT(!equal(int_<0>, int{1}));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(int_<0>, int{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(int_<0>, int{1}));
 
-    BOOST_HANA_STATIC_ASSERT(equal(int_<0>, long{0}));
-    BOOST_HANA_STATIC_ASSERT(!equal(int_<1>, long{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(int_<0>, long{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(int_<1>, long{0}));
 
-    BOOST_HANA_STATIC_ASSERT(equal(int_<0>, float{0}));
-    BOOST_HANA_STATIC_ASSERT(!equal(int_<1>, float{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(int_<0>, float{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(int_<1>, float{0}));
 
 
     // other == Integral
-    BOOST_HANA_STATIC_ASSERT(equal(int{0}, int_<0>));
-    BOOST_HANA_STATIC_ASSERT(!equal(int{1}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(int{0}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(int{1}, int_<0>));
 
-    BOOST_HANA_STATIC_ASSERT(equal(long{0}, int_<0>));
-    BOOST_HANA_STATIC_ASSERT(!equal(long{1}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(long{0}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(long{1}, int_<0>));
 
-    BOOST_HANA_STATIC_ASSERT(equal(float{0}, int_<0>));
-    BOOST_HANA_STATIC_ASSERT(!equal(float{1}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(equal(float{0}, int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(float{1}, int_<0>));
 }
diff --git a/test/integral/comparable/laws.cpp b/test/integral/comparable/laws.cpp
index d5481dbc5..3d41f002d 100644
--- a/test/integral/comparable/laws.cpp
+++ b/test/integral/comparable/laws.cpp
@@ -7,14 +7,14 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/integral.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 template <typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         Comparable::laws::check(
             list(
                 integral<T, 0>, integral<U, 0>,
diff --git a/test/integral/constant/laws.cpp b/test/integral/constant/laws.cpp
index da4477f39..7e6be0e8e 100644
--- a/test/integral/constant/laws.cpp
+++ b/test/integral/constant/laws.cpp
@@ -7,14 +7,14 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/integral.hpp>
 
 #include <boost/hana/constant/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 template <typename T>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(Constant::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Constant::laws::check(
         list(
             integral<T, 0>,
             integral<T, 1>,
diff --git a/test/integral/literals.cpp b/test/integral/literals.cpp
index 6ed6b1b26..053cac855 100644
--- a/test/integral/literals.cpp
+++ b/test/integral/literals.cpp
@@ -6,20 +6,20 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 using namespace literals;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(0_c == llong<0>);
-    BOOST_HANA_STATIC_ASSERT(1_c == llong<1>);
-    BOOST_HANA_STATIC_ASSERT(12_c == llong<12>);
-    BOOST_HANA_STATIC_ASSERT(123_c == llong<123>);
-    BOOST_HANA_STATIC_ASSERT(1234567_c == llong<1234567>);
-    BOOST_HANA_STATIC_ASSERT(-34_c == llong<-34>);
+    BOOST_HANA_CONSTANT_ASSERT(0_c == llong<0>);
+    BOOST_HANA_CONSTANT_ASSERT(1_c == llong<1>);
+    BOOST_HANA_CONSTANT_ASSERT(12_c == llong<12>);
+    BOOST_HANA_CONSTANT_ASSERT(123_c == llong<123>);
+    BOOST_HANA_CONSTANT_ASSERT(1234567_c == llong<1234567>);
+    BOOST_HANA_CONSTANT_ASSERT(-34_c == llong<-34>);
 
-    BOOST_HANA_STATIC_ASSERT(decltype_(-1234_c) == decltype_(llong<-1234>));
-    BOOST_HANA_STATIC_ASSERT(-12_c < 0_c);
+    BOOST_HANA_CONSTANT_ASSERT(decltype_(-1234_c) == decltype_(llong<-1234>));
+    BOOST_HANA_CONSTANT_ASSERT(-12_c < 0_c);
 }
diff --git a/test/integral/logical.cpp b/test/integral/logical.cpp
index 7f4d71ca1..b32187ff4 100644
--- a/test/integral/logical.cpp
+++ b/test/integral/logical.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/bool.hpp>
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
@@ -16,43 +16,45 @@ struct T; struct E;
 constexpr struct { } invalid{};
 
 auto test_eval_if = [](auto true_, auto false_) {
-    BOOST_HANA_STATIC_ASSERT(eval_if(true_,
+    auto x = eval_if(true_,
         [](auto) { return type<T>; },
         [](auto id) { id(invalid)("would fail"); return type<E>; }
-    ) == type<T>);
+    );
+    BOOST_HANA_CONSTANT_ASSERT(x == type<T>);
 
-    BOOST_HANA_STATIC_ASSERT(eval_if(false_,
+    auto y = eval_if(false_,
         [](auto id) { id(invalid)("would fail"); return type<T>; },
         [](auto) { return type<E>; }
-    ) == type<E>);
+    );
+    BOOST_HANA_CONSTANT_ASSERT(y == type<E>);
 };
 
 auto test_if = [](auto true_, auto false_) {
-    BOOST_HANA_STATIC_ASSERT(if_(true_, type<T>, type<E>) == type<T>);
-    BOOST_HANA_STATIC_ASSERT(if_(false_, type<T>, type<E>) == type<E>);
+    BOOST_HANA_CONSTANT_ASSERT(if_(true_, type<T>, type<E>) == type<T>);
+    BOOST_HANA_CONSTANT_ASSERT(if_(false_, type<T>, type<E>) == type<E>);
 };
 
 auto test_and = [](auto true_, auto false_) {
-    BOOST_HANA_STATIC_ASSERT(!or_(false_));
-    BOOST_HANA_STATIC_ASSERT(or_(true_));
-    BOOST_HANA_STATIC_ASSERT(!or_(false_, false_));
-    BOOST_HANA_STATIC_ASSERT(or_(false_, true_));
-    BOOST_HANA_STATIC_ASSERT(or_(false_, false_, true_));
-    // BOOST_HANA_STATIC_ASSERT(or_(true_, invalid, invalid));
+    BOOST_HANA_CONSTANT_ASSERT(!or_(false_));
+    BOOST_HANA_CONSTANT_ASSERT(or_(true_));
+    BOOST_HANA_CONSTANT_ASSERT(!or_(false_, false_));
+    BOOST_HANA_CONSTANT_ASSERT(or_(false_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(or_(false_, false_, true_));
+    // BOOST_HANA_CONSTANT_ASSERT(or_(true_, invalid, invalid));
 };
 
 auto test_or = [](auto true_, auto false_) {
-    BOOST_HANA_STATIC_ASSERT(and_(true_));
-    BOOST_HANA_STATIC_ASSERT(!and_(false_));
-    BOOST_HANA_STATIC_ASSERT(and_(true_, true_));
-    BOOST_HANA_STATIC_ASSERT(!and_(true_, false_));
-    BOOST_HANA_STATIC_ASSERT(!and_(true_, true_, false_));
-    // BOOST_HANA_STATIC_ASSERT(!and_(false_, invalid, invalid));
+    BOOST_HANA_CONSTANT_ASSERT(and_(true_));
+    BOOST_HANA_CONSTANT_ASSERT(!and_(false_));
+    BOOST_HANA_CONSTANT_ASSERT(and_(true_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(!and_(true_, false_));
+    BOOST_HANA_CONSTANT_ASSERT(!and_(true_, true_, false_));
+    // BOOST_HANA_CONSTANT_ASSERT(!and_(false_, invalid, invalid));
 };
 
 auto test_not = [](auto true_, auto false_) {
-    BOOST_HANA_STATIC_ASSERT(not_(false_));
-    BOOST_HANA_STATIC_ASSERT(not_(not_(true_)));
+    BOOST_HANA_CONSTANT_ASSERT(not_(false_));
+    BOOST_HANA_CONSTANT_ASSERT(not_(not_(true_)));
 };
 
 auto test = [](auto true_, auto false_) {
diff --git a/test/integral/operators.cpp b/test/integral/operators.cpp
index 1e3626cca..78eb1c836 100644
--- a/test/integral/operators.cpp
+++ b/test/integral/operators.cpp
@@ -6,39 +6,39 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     // Arithmetic
-    BOOST_HANA_STATIC_ASSERT(+int_<1> == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(-int_<1> == int_<-1>);
-    BOOST_HANA_STATIC_ASSERT(int_<1> + int_<2> == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(int_<1> - int_<2> == int_<-1>);
-    BOOST_HANA_STATIC_ASSERT(int_<3> * int_<2> == int_<6>);
-    BOOST_HANA_STATIC_ASSERT(int_<6> / int_<3> == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(int_<6> % int_<4> == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(~int_<6> == int_<~6>);
-    BOOST_HANA_STATIC_ASSERT((int_<6> & int_<3>) == int_<6 & 3>);
-    BOOST_HANA_STATIC_ASSERT(int_<6> | int_<3> == int_<6 | 3>);
-    BOOST_HANA_STATIC_ASSERT(int_<6> ^ int_<3> == int_<6 ^ 3>);
-    BOOST_HANA_STATIC_ASSERT((int_<6> << int_<3>) == int_<(6 << 3)>);
-    BOOST_HANA_STATIC_ASSERT((int_<6> >> int_<3>) == int_<(6 >> 3)>);
+    BOOST_HANA_CONSTANT_ASSERT(+int_<1> == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(-int_<1> == int_<-1>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> + int_<2> == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> - int_<2> == int_<-1>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<3> * int_<2> == int_<6>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<6> / int_<3> == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<6> % int_<4> == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(~int_<6> == int_<~6>);
+    BOOST_HANA_CONSTANT_ASSERT((int_<6> & int_<3>) == int_<6 & 3>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<6> | int_<3> == int_<6 | 3>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<6> ^ int_<3> == int_<6 ^ 3>);
+    BOOST_HANA_CONSTANT_ASSERT((int_<6> << int_<3>) == int_<(6 << 3)>);
+    BOOST_HANA_CONSTANT_ASSERT((int_<6> >> int_<3>) == int_<(6 >> 3)>);
 
     // Comparison
-    BOOST_HANA_STATIC_ASSERT(int_<0> == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<1> != int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<0> < int_<1>);
-    BOOST_HANA_STATIC_ASSERT(int_<0> <= int_<1>);
-    BOOST_HANA_STATIC_ASSERT(int_<0> <= int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<1> > int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<1> >= int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<0> >= int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<0> == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> != int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<0> < int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<0> <= int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<0> <= int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> > int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<1> >= int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<0> >= int_<0>);
 
     // Logical
-    BOOST_HANA_STATIC_ASSERT(int_<3> || int_<0>);
-    BOOST_HANA_STATIC_ASSERT(int_<3> && int_<1>);
-    BOOST_HANA_STATIC_ASSERT(!int_<0>);
-    BOOST_HANA_STATIC_ASSERT(!!int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<3> || int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(int_<3> && int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(!int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(!!int_<3>);
 }
diff --git a/test/integral/orderable/laws.cpp b/test/integral/orderable/laws.cpp
index dc84f4e87..ab500487b 100644
--- a/test/integral/orderable/laws.cpp
+++ b/test/integral/orderable/laws.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/orderable/laws.hpp>
 using namespace boost::hana;
@@ -14,7 +14,7 @@ using namespace boost::hana;
 
 template <typename T, typename U>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(Orderable::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Orderable::laws::check(
         list(
             integral<T, 0>, integral<U, 0>,
             integral<T, 1>, integral<U, 1>,
diff --git a/test/integral/orderable/less.cpp b/test/integral/orderable/less.cpp
index e0bb67e0a..f72efce39 100644
--- a/test/integral/orderable/less.cpp
+++ b/test/integral/orderable/less.cpp
@@ -6,45 +6,45 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
     // Integral < Integral
-    BOOST_HANA_STATIC_ASSERT(less(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<0>, int_<0>)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<1>, int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(less(int_<0>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(not_(less(int_<0>, int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(not_(less(int_<1>, int_<0>)));
 
-    BOOST_HANA_STATIC_ASSERT(less(int_<0>, long_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<0>, long_<0>)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<1>, long_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(less(int_<0>, long_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(not_(less(int_<0>, long_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(not_(less(int_<1>, long_<0>)));
 
 
     // Integral < other
-    BOOST_HANA_STATIC_ASSERT(less(int_<0>, int{1}));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<0>, int{0})));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<1>, int{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(int_<0>, int{1}));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<0>, int{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<1>, int{0})));
 
-    BOOST_HANA_STATIC_ASSERT(less(int_<0>, long{1}));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<0>, long{0})));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<1>, long{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(int_<0>, long{1}));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<0>, long{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<1>, long{0})));
 
-    BOOST_HANA_STATIC_ASSERT(less(int_<0>, float{1}));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<0>, float{0})));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int_<1>, float{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(int_<0>, float{1}));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<0>, float{0})));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int_<1>, float{0})));
 
 
     // other < Integral
-    BOOST_HANA_STATIC_ASSERT(less(int{0}, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int{0}, int_<0>)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int{1}, int_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(int{0}, int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int{0}, int_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int{1}, int_<0>)));
 
-    BOOST_HANA_STATIC_ASSERT(less(int{0}, long_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int{0}, long_<0>)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(int{1}, long_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(int{0}, long_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int{0}, long_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(int{1}, long_<0>)));
 
-    BOOST_HANA_STATIC_ASSERT(less(float{0}, long_<1>));
-    BOOST_HANA_STATIC_ASSERT(not_(less(float{0}, long_<0>)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(float{1}, long_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(float{0}, long_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(float{0}, long_<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(float{1}, long_<0>)));
 }
diff --git a/test/iterable/at.cpp b/test/iterable/at.cpp
index fd64a6dfc..cae7f7f8c 100644
--- a/test/iterable/at.cpp
+++ b/test/iterable/at.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,14 +16,14 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, iterable(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<0>, iterable(int_<0>)) == int_<0>);
 
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, iterable(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<1>, iterable(int_<0>, int_<1>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<0>, iterable(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<1>, iterable(int_<0>, int_<1>)) == int_<1>);
 
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, iterable(int_<0>, int_<1>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<1>, iterable(int_<0>, int_<1>, int_<2>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<2>, iterable(int_<0>, int_<1>, int_<2>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<0>, iterable(int_<0>, int_<1>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<1>, iterable(int_<0>, int_<1>, int_<2>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<2>, iterable(int_<0>, int_<1>, int_<2>)) == int_<2>);
 }
 
 int main() {
diff --git a/test/iterable/drop.cpp b/test/iterable/drop.cpp
index a951c1139..b24ebb3ca 100644
--- a/test/iterable/drop.cpp
+++ b/test/iterable/drop.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,17 +16,17 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, iterable()) == iterable());
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, iterable()) == iterable());
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, iterable()) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, iterable()) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, iterable()) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, iterable()) == iterable());
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, iterable(int_<0>)) == iterable(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, iterable(int_<0>)) == iterable());
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, iterable(int_<0>)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, iterable(int_<0>)) == iterable(int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, iterable(int_<0>)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, iterable(int_<0>)) == iterable());
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, iterable(int_<0>, int_<1>)) == iterable(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, iterable(int_<0>, int_<1>)) == iterable(int_<1>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, iterable(int_<0>, int_<1>)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, iterable(int_<0>, int_<1>)) == iterable(int_<0>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, iterable(int_<0>, int_<1>)) == iterable(int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, iterable(int_<0>, int_<1>)) == iterable());
 }
 
 int main() {
diff --git a/test/iterable/drop_until.cpp b/test/iterable/drop_until.cpp
index d77ee4b1d..8c0acb264 100644
--- a/test/iterable/drop_until.cpp
+++ b/test/iterable/drop_until.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/iterable/mcd.hpp>
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -17,15 +17,15 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable()) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable()) == iterable());
 
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(true_)) == iterable(true_));
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(false_)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(true_)) == iterable(true_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(false_)) == iterable());
 
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(true_, true_)) == iterable(true_, true_));
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(true_, false_)) == iterable(true_, false_));
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(false_, true_)) == iterable(true_));
-    BOOST_HANA_STATIC_ASSERT(drop_until(id, iterable(false_, false_)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(true_, true_)) == iterable(true_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(true_, false_)) == iterable(true_, false_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(false_, true_)) == iterable(true_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_until(id, iterable(false_, false_)) == iterable());
 }
 
 int main() {
diff --git a/test/iterable/drop_while.cpp b/test/iterable/drop_while.cpp
index c8f47f5a9..061a54e9c 100644
--- a/test/iterable/drop_while.cpp
+++ b/test/iterable/drop_while.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/iterable/mcd.hpp>
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -17,15 +17,15 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable()) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable()) == iterable());
 
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(true_)) == iterable());
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(false_)) == iterable(false_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(true_)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(false_)) == iterable(false_));
 
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(true_, true_)) == iterable());
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(true_, false_)) == iterable(false_));
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(false_, true_)) == iterable(false_, true_));
-    BOOST_HANA_STATIC_ASSERT(drop_while(id, iterable(false_, false_)) == iterable(false_, false_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(true_, true_)) == iterable());
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(true_, false_)) == iterable(false_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(false_, true_)) == iterable(false_, true_));
+    BOOST_HANA_CONSTANT_ASSERT(drop_while(id, iterable(false_, false_)) == iterable(false_, false_));
 }
 
 int main() {
diff --git a/test/iterable/foldable/foldl.cpp b/test/iterable/foldable/foldl.cpp
index 29be50554..0ea371b92 100644
--- a/test/iterable/foldable/foldl.cpp
+++ b/test/iterable/foldable/foldl.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -27,11 +27,11 @@ void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
     constexpr auto s = x<-1>;
 
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, iterable()) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, iterable(x<0>)) == f(s, x<0>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, iterable(x<0>, x<1>)) == f(f(s, x<0>), x<1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, iterable(x<0>, x<1>, x<2>)) == f(f(f(s, x<0>), x<1>), x<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, iterable(x<0>, x<1>, x<2>, x<3>)) == f(f(f(f(s, x<0>), x<1>), x<2>), x<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, iterable()) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, iterable(x<0>)) == f(s, x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, iterable(x<0>, x<1>)) == f(f(s, x<0>), x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, iterable(x<0>, x<1>, x<2>)) == f(f(f(s, x<0>), x<1>), x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, iterable(x<0>, x<1>, x<2>, x<3>)) == f(f(f(f(s, x<0>), x<1>), x<2>), x<3>));
 }
 
 int main() {
diff --git a/test/iterable/foldable/foldl1.cpp b/test/iterable/foldable/foldl1.cpp
index 1c1df78a7..2555f215f 100644
--- a/test/iterable/foldable/foldl1.cpp
+++ b/test/iterable/foldable/foldl1.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -26,10 +26,10 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, iterable(x<0>)) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, iterable(x<0>, x<1>)) == f(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, iterable(x<0>, x<1>, x<2>)) == f(f(x<0>, x<1>), x<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl1(f, iterable(x<0>, x<1>, x<2>, x<3>)) == f(f(f(x<0>, x<1>), x<2>), x<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, iterable(x<0>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, iterable(x<0>, x<1>)) == f(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, iterable(x<0>, x<1>, x<2>)) == f(f(x<0>, x<1>), x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl1(f, iterable(x<0>, x<1>, x<2>, x<3>)) == f(f(f(x<0>, x<1>), x<2>), x<3>));
 }
 
 int main() {
diff --git a/test/iterable/foldable/foldr.cpp b/test/iterable/foldable/foldr.cpp
index d4fb0dea9..ca35b5258 100644
--- a/test/iterable/foldable/foldr.cpp
+++ b/test/iterable/foldable/foldr.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -27,11 +27,11 @@ void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
     constexpr auto s = x<-1>;
 
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, iterable()) == s);
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, iterable(x<0>)) == f(x<0>, s));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, iterable(x<0>, x<1>)) == f(x<0>, f(x<1>, s)));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, iterable(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, f(x<2>, s))));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, iterable(x<0>, x<1>, x<2>, x<3>)) == f(x<0>, f(x<1>, f(x<2>, f(x<3>, s)))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, iterable()) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, iterable(x<0>)) == f(x<0>, s));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, iterable(x<0>, x<1>)) == f(x<0>, f(x<1>, s)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, iterable(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, f(x<2>, s))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, iterable(x<0>, x<1>, x<2>, x<3>)) == f(x<0>, f(x<1>, f(x<2>, f(x<3>, s)))));
 }
 
 int main() {
diff --git a/test/iterable/foldable/foldr1.cpp b/test/iterable/foldable/foldr1.cpp
index a3e5cfe93..2fc8ec7f6 100644
--- a/test/iterable/foldable/foldr1.cpp
+++ b/test/iterable/foldable/foldr1.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -26,10 +26,10 @@ template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, iterable(x<0>)) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, iterable(x<0>, x<1>)) == f(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, iterable(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT(foldr1(f, iterable(x<0>, x<1>, x<2>, x<3>)) == f(x<0>, f(x<1>, f(x<2>, x<3>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, iterable(x<0>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, iterable(x<0>, x<1>)) == f(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, iterable(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr1(f, iterable(x<0>, x<1>, x<2>, x<3>)) == f(x<0>, f(x<1>, f(x<2>, x<3>))));
 }
 
 int main() {
diff --git a/test/iterable/last.cpp b/test/iterable/last.cpp
index e0663c9e2..66a29ed32 100644
--- a/test/iterable/last.cpp
+++ b/test/iterable/last.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/iterable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/iterable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,9 +18,9 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     constexpr auto iterable = detail::minimal::iterable<mcd>;
-    BOOST_HANA_STATIC_ASSERT(last(iterable(x<0>)) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(last(iterable(x<0>, x<1>)) == x<1>);
-    BOOST_HANA_STATIC_ASSERT(last(iterable(x<0>, x<1>, x<2>)) == x<2>);
+    BOOST_HANA_CONSTEXPR_ASSERT(last(iterable(x<0>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(last(iterable(x<0>, x<1>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(last(iterable(x<0>, x<1>, x<2>)) == x<2>);
 }
 
 int main() {
diff --git a/test/lazy/applicative/ap.cpp b/test/lazy/applicative/ap.cpp
index ca9b99ba3..4ff14d468 100644
--- a/test/lazy/applicative/ap.cpp
+++ b/test/lazy/applicative/ap.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include "../comparable.hpp"
 #include <tuple>
@@ -27,9 +27,9 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(ap(lazy(f), lazy(x<0>)) == lazy(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(lazy(f), lazy(x<0>), lazy(x<1>)) == lazy(f(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(ap(lazy(f), lazy(x<0>), lazy(x<1>), lazy(x<2>)) == lazy(f(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(lazy(f), lazy(x<0>)) == lazy(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(lazy(f), lazy(x<0>), lazy(x<1>)) == lazy(f(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(lazy(f), lazy(x<0>), lazy(x<1>), lazy(x<2>)) == lazy(f(x<0>, x<1>, x<2>)));
 
     // The function is not applied.
     ap(lazy(invalid), lazy(x<0>));
diff --git a/test/lazy/applicative/lift.cpp b/test/lazy/applicative/lift.cpp
index 0c051476e..06abf8216 100644
--- a/test/lazy/applicative/lift.cpp
+++ b/test/lazy/applicative/lift.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include "../comparable.hpp"
 using namespace boost::hana;
@@ -17,6 +17,6 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lift<Lazy>(x<0>) == lazy(x<0>));
-    BOOST_HANA_STATIC_ASSERT(lift<Lazy>(x<1>) == lazy(x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<Lazy>(x<0>) == lazy(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<Lazy>(x<1>) == lazy(x<1>));
 }
diff --git a/test/lazy/eval.cpp b/test/lazy/eval.cpp
index f395fc3cf..0ab1c4fb2 100644
--- a/test/lazy/eval.cpp
+++ b/test/lazy/eval.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,6 +15,6 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(eval(lazy(x<0>)) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(eval(lazy(x<1>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(eval(lazy(x<0>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(eval(lazy(x<1>)) == x<1>);
 }
diff --git a/test/lazy/functor/fmap.cpp b/test/lazy/functor/fmap.cpp
index bcb48e51c..16ee6bc73 100644
--- a/test/lazy/functor/fmap.cpp
+++ b/test/lazy/functor/fmap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 
 #include "../comparable.hpp"
@@ -19,10 +19,10 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(fmap(f, lazy(1)) == lazy(f(1)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, lazy(2.2)) == lazy(f(2.2)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, lazy(1)) == lazy(f(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, lazy(2.2)) == lazy(f(2.2)));
 
-    BOOST_HANA_STATIC_ASSERT(fmap(id, lazy(1)) == lazy(1));
-    BOOST_HANA_STATIC_ASSERT(fmap(id, lazy('2')) == lazy('2'));
-    BOOST_HANA_STATIC_ASSERT(fmap(id, lazy(3.3)) == lazy(3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(id, lazy(1)) == lazy(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(id, lazy('2')) == lazy('2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(id, lazy(3.3)) == lazy(3.3));
 }
diff --git a/test/lazy/functor/laws.cpp b/test/lazy/functor/laws.cpp
index bd2575c5c..c001e2f8d 100644
--- a/test/lazy/functor/laws.cpp
+++ b/test/lazy/functor/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 #include <boost/hana/list/instance.hpp>
 
@@ -30,7 +30,7 @@ template <int i, int j>
 constexpr _f<i, j> f{};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(lazy(x<0>)),
         list(
             f<1, 1>,
diff --git a/test/lazy/lazy.cpp b/test/lazy/lazy.cpp
index 4b6537610..bdc96cdd5 100644
--- a/test/lazy/lazy.cpp
+++ b/test/lazy/lazy.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include "comparable.hpp"
 #include <tuple>
@@ -27,10 +27,10 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lazy(f)() == lazy(f()));
-    BOOST_HANA_STATIC_ASSERT(lazy(f)(x<0>) == lazy(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(lazy(f)(x<0>, x<1>) == lazy(f(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(lazy(f)(x<0>, x<1>, x<2>) == lazy(f(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(lazy(f)() == lazy(f()));
+    BOOST_HANA_CONSTEXPR_ASSERT(lazy(f)(x<0>) == lazy(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(lazy(f)(x<0>, x<1>) == lazy(f(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(lazy(f)(x<0>, x<1>, x<2>) == lazy(f(x<0>, x<1>, x<2>)));
 
     // The function is not applied.
     lazy(invalid)();
diff --git a/test/lazy/monad/bind.cpp b/test/lazy/monad/bind.cpp
index fbeb9c021..d2bdf4c66 100644
--- a/test/lazy/monad/bind.cpp
+++ b/test/lazy/monad/bind.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include "../comparable.hpp"
 #include <tuple>
@@ -23,6 +23,6 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(bind(lazy(x<0>), f) == f(x<0>));
-    BOOST_HANA_STATIC_ASSERT(bind(lazy(x<1>), f) == f(x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(bind(lazy(x<0>), f) == f(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(bind(lazy(x<1>), f) == f(x<1>));
 }
diff --git a/test/lazy/monad/flatten.cpp b/test/lazy/monad/flatten.cpp
index e2203d9be..880685709 100644
--- a/test/lazy/monad/flatten.cpp
+++ b/test/lazy/monad/flatten.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/lazy.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include "../comparable.hpp"
 using namespace boost::hana;
@@ -18,7 +18,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(flatten(lazy(lazy(x<0>))) == lazy(x<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(lazy(lazy(x<1>))) == lazy(x<1>));
-    BOOST_HANA_STATIC_ASSERT(flatten(lazy(lazy(lazy(x<1>)))) == lazy(lazy(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(lazy(lazy(x<0>))) == lazy(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(lazy(lazy(x<1>))) == lazy(x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(lazy(lazy(lazy(x<1>)))) == lazy(lazy(x<1>)));
 }
diff --git a/test/list/instance/foldable/foldl.cpp b/test/list/instance/foldable/foldl.cpp
index f57a1118a..21cea437a 100644
--- a/test/list/instance/foldable/foldl.cpp
+++ b/test/list/instance/foldable/foldl.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/detail/minimal/comparable.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,9 +18,12 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x, auto y) {
     return std::make_tuple(x, y);
 };
 
+template <int i>
+constexpr auto x = detail::minimal::comparable<>(i);
+
 int main() {
-    BOOST_HANA_STATIC_ASSERT(foldl(f, int_<0>, list()) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(foldl(f, int_<0>, list(int_<1>)) == f(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, int_<0>, list(int_<1>, int_<2>)) == f(f(int_<0>, int_<1>), int_<2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, int_<0>, list(int_<1>, int_<2>, int_<3>)) == f(f(f(int_<0>, int_<1>), int_<2>), int_<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, x<0>, list()) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, x<0>, list(x<1>)) == f(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, x<0>, list(x<1>, x<2>)) == f(f(x<0>, x<1>), x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, x<0>, list(x<1>, x<2>, x<3>)) == f(f(f(x<0>, x<1>), x<2>), x<3>));
 }
diff --git a/test/list/instance/foldable/foldr.cpp b/test/list/instance/foldable/foldr.cpp
index 0c327a3b8..ab2962189 100644
--- a/test/list/instance/foldable/foldr.cpp
+++ b/test/list/instance/foldable/foldr.cpp
@@ -6,8 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/minimal/comparable.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,18 +19,12 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x, auto s) {
 };
 
 template <int i>
-struct X {
-    template <int j>
-    constexpr bool operator==(X<j>) const { return i == j; }
-};
-
-template <int i>
-constexpr X<i> x{};
+constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
     constexpr auto s = x<-1>;
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, list()) == s);
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, list(x<0>)) == f(x<0>, s));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, list(x<0>, x<1>)) == f(x<0>, f(x<1>, s)));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, list(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, f(x<2>, s))));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, list()) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, list(x<0>)) == f(x<0>, s));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, list(x<0>, x<1>)) == f(x<0>, f(x<1>, s)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, list(x<0>, x<1>, x<2>)) == f(x<0>, f(x<1>, f(x<2>, s))));
 }
diff --git a/test/list/instance/foldable/length.cpp b/test/list/instance/foldable/length.cpp
index 777f685d4..c8191d43d 100644
--- a/test/list/instance/foldable/length.cpp
+++ b/test/list/instance/foldable/length.cpp
@@ -6,16 +6,16 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(length(list()) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(length(list(int_<0>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(length(list(int_<0>, int_<1>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(length(list(int_<0>, int_<1>, int_<2>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(length(list(0, '1', 2.2)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(length(list(0, 1, 2)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list()) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(int_<0>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(int_<0>, int_<1>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(int_<0>, int_<1>, int_<2>)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(0, '1', 2.2)) == int_<3>);
+    BOOST_HANA_CONSTANT_ASSERT(length(list(0, 1, 2)) == int_<3>);
 }
diff --git a/test/list/instance/foldable/unpack.cpp b/test/list/instance/foldable/unpack.cpp
index 354c5cc93..41507536f 100644
--- a/test/list/instance/foldable/unpack.cpp
+++ b/test/list/instance/foldable/unpack.cpp
@@ -6,21 +6,24 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/detail/minimal/comparable.hpp>
 
 #include <tuple>
 using namespace boost::hana;
 
 
-BOOST_HANA_CONSTEXPR_LAMBDA auto tuple = [](auto ...x) {
+BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...x) {
     return std::make_tuple(x...);
 };
 
+template <int i>
+constexpr auto x = detail::minimal::comparable<>(i);
+
 int main() {
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, list()) == tuple());
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, list(int_<0>)) == tuple(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, list(int_<0>, int_<1>)) == tuple(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, list(int_<0>, int_<1>, int_<2>)) == tuple(int_<0>, int_<1>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, list()) == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, list(x<0>)) == f(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, list(x<0>, x<1>)) == f(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, list(x<0>, x<1>, x<2>)) == f(x<0>, x<1>, x<2>));
 }
diff --git a/test/list/instance/functor/fmap.cpp b/test/list/instance/functor/fmap.cpp
index eba97c675..9bcde9885 100644
--- a/test/list/instance/functor/fmap.cpp
+++ b/test/list/instance/functor/fmap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -15,9 +15,9 @@ using namespace boost::hana;
 BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto i) { return i + int_<1>; };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(int_<1>)) == list(f(int_<1>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(int_<1>, int_<2>)) == list(f(int_<1>), f(int_<2>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(int_<1>, int_<2>, int_<3>)) == list(f(int_<1>), f(int_<2>), f(int_<3>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(1, 2, 3)) == list(f(1), f(2), f(3)));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, list(int_<1>)) == list(f(int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, list(int_<1>, int_<2>)) == list(f(int_<1>), f(int_<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, list(int_<1>, int_<2>, int_<3>)) == list(f(int_<1>), f(int_<2>), f(int_<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, list(1, 2, 3)) == list(f(1), f(2), f(3)));
 }
diff --git a/test/list/instance/functor/laws.cpp b/test/list/instance/functor/laws.cpp
index 227de3e1c..6cd7f183d 100644
--- a/test/list/instance/functor/laws.cpp
+++ b/test/list/instance/functor/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 
 #include <tuple>
@@ -28,7 +28,7 @@ template <int i, int j>
 constexpr _f<i, j> f{};
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(
             list(),
             list(x<0>),
diff --git a/test/list/instance/iterable/at.cpp b/test/list/instance/iterable/at.cpp
index 131b94e23..00b9001d1 100644
--- a/test/list/instance/iterable/at.cpp
+++ b/test/list/instance/iterable/at.cpp
@@ -6,16 +6,16 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, list(int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<0>, list(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, list(int_<0>, int_<1>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<1>, list(int_<0>, int_<1>, int_<2>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<3>, list(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<3>);
-    BOOST_HANA_STATIC_ASSERT(at(size_t<2>, list(0, '1', 2.2, int_<3>)) == 2.2);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, list(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<0>, list(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<1>, list(int_<0>, int_<1>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<1>, list(int_<0>, int_<1>, int_<2>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(size_t<3>, list(int_<0>, int_<1>, int_<2>, int_<3>)) == int_<3>);
+    BOOST_HANA_CONSTEXPR_ASSERT(at(size_t<2>, list(0, '1', 2.2, int_<3>)) == 2.2);
 }
diff --git a/test/list/instance/iterable/head.cpp b/test/list/instance/iterable/head.cpp
index 03bb75698..2588883a7 100644
--- a/test/list/instance/iterable/head.cpp
+++ b/test/list/instance/iterable/head.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -14,8 +14,8 @@ using namespace boost::hana;
 struct non_trivial { virtual ~non_trivial() { } };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(head(list(int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(list(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(list(int_<0>, int_<1>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(list(int_<0>, int_<1>, non_trivial{})) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(list(int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(list(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(list(int_<0>, int_<1>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(list(int_<0>, int_<1>, non_trivial{})) == int_<0>);
 }
diff --git a/test/list/instance/iterable/is_empty.cpp b/test/list/instance/iterable/is_empty.cpp
index 5cb3e6333..3a2be916c 100644
--- a/test/list/instance/iterable/is_empty.cpp
+++ b/test/list/instance/iterable/is_empty.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(list()));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(list(0)));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(list(0, '1')));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(list(0, '1', 2.2)));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(list()));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(list(0)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(list(0, '1')));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(list(0, '1', 2.2)));
 }
diff --git a/test/list/instance/iterable/tail.cpp b/test/list/instance/iterable/tail.cpp
index 8f30c4a1c..e4cc9ae26 100644
--- a/test/list/instance/iterable/tail.cpp
+++ b/test/list/instance/iterable/tail.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(tail(list(int_<0>)) == list());
-    BOOST_HANA_STATIC_ASSERT(tail(list(int_<0>, int_<1>)) == list(int_<1>));
-    BOOST_HANA_STATIC_ASSERT(tail(list(int_<0>, int_<1>, int_<2>)) == list(int_<1>, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(tail(list(int_<0>, int_<1>, int_<2>, int_<3>)) == list(int_<1>, int_<2>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(list(int_<0>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(tail(list(int_<0>, int_<1>)) == list(int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(list(int_<0>, int_<1>, int_<2>)) == list(int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(list(int_<0>, int_<1>, int_<2>, int_<3>)) == list(int_<1>, int_<2>, int_<3>));
 }
diff --git a/test/list/instance/list/concat.cpp b/test/list/instance/list/concat.cpp
index 9f2b536f3..fe1986b95 100644
--- a/test/list/instance/list/concat.cpp
+++ b/test/list/instance/list/concat.cpp
@@ -6,16 +6,16 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(concat(list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(concat(list(), list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(concat(list(0), list()) == list(0));
-    BOOST_HANA_STATIC_ASSERT(concat(list(0), list('1')) == list(0, '1'));
-    BOOST_HANA_STATIC_ASSERT(concat(list(0), list('1', 2.2)) == list(0, '1', 2.2));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(0), list()) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(0), list('1')) == list(0, '1'));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(0), list('1', 2.2)) == list(0, '1', 2.2));
 
-    BOOST_HANA_STATIC_ASSERT(concat(list(0, nullptr), list('1', 2.2)) == list(0, nullptr, '1', 2.2));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(0, nullptr), list('1', 2.2)) == list(0, nullptr, '1', 2.2));
 }
diff --git a/test/list/instance/list/cons.cpp b/test/list/instance/list/cons.cpp
index adf896c67..3774986d9 100644
--- a/test/list/instance/list/cons.cpp
+++ b/test/list/instance/list/cons.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(cons(0, list()) == list(0));
-    BOOST_HANA_STATIC_ASSERT(cons(0, list('1')) == list(0, '1'));
-    BOOST_HANA_STATIC_ASSERT(cons(0, list('1', 2.2)) == list(0, '1', 2.2));
-    BOOST_HANA_STATIC_ASSERT(cons(0, list('1', 2.2, nullptr)) == list(0, '1', 2.2, nullptr));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(0, list()) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(0, list('1')) == list(0, '1'));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(0, list('1', 2.2)) == list(0, '1', 2.2));
+    BOOST_HANA_CONSTEXPR_ASSERT(cons(0, list('1', 2.2, nullptr)) == list(0, '1', 2.2, nullptr));
 }
diff --git a/test/list/instance/list/init.cpp b/test/list/instance/list/init.cpp
index 63b4f6296..fe5c73455 100644
--- a/test/list/instance/list/init.cpp
+++ b/test/list/instance/list/init.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(init(list(0)) == list());
-    BOOST_HANA_STATIC_ASSERT(init(list(0, '1')) == list(0));
-    BOOST_HANA_STATIC_ASSERT(init(list(0, '1', 2.2)) == list(0, '1'));
-    BOOST_HANA_STATIC_ASSERT(init(list(0, '1', 2.2, nullptr)) == list(0, '1', 2.2));
+    BOOST_HANA_CONSTANT_ASSERT(init(list(0)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(0, '1')) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(0, '1', 2.2)) == list(0, '1'));
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(0, '1', 2.2, nullptr)) == list(0, '1', 2.2));
 }
diff --git a/test/list/instance/list/nil.cpp b/test/list/instance/list/nil.cpp
index 5161307a7..f50052aa5 100644
--- a/test/list/instance/list/nil.cpp
+++ b/test/list/instance/list/nil.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(nil<List> == list());
+    BOOST_HANA_CONSTANT_ASSERT(nil<List> == list());
 }
diff --git a/test/list/instance/list/snoc.cpp b/test/list/instance/list/snoc.cpp
index 7c27b70f8..b2e9e77fa 100644
--- a/test/list/instance/list/snoc.cpp
+++ b/test/list/instance/list/snoc.cpp
@@ -6,12 +6,12 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(snoc(list(), 0) == list(0));
-    BOOST_HANA_STATIC_ASSERT(snoc(list('1'), 0) == list('1', 0));
-    BOOST_HANA_STATIC_ASSERT(snoc(list('1', 2.2), 0) == list('1', 2.2, 0));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(), 0) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list('1'), 0) == list('1', 0));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list('1', 2.2), 0) == list('1', 2.2, 0));
 }
diff --git a/test/list/instance/list/take.cpp b/test/list/instance/list/take.cpp
index 79fbd5ffe..23281bce5 100644
--- a/test/list/instance/list/take.cpp
+++ b/test/list/instance/list/take.cpp
@@ -6,22 +6,22 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<1>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<2>, list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list(0)) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list(0)) == list(0));
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list(0)) == list(0));
-    BOOST_HANA_STATIC_ASSERT(take(int_<3>, list(0)) == list(0));
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list(0)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<1>, list(0)) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<2>, list(0)) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<3>, list(0)) == list(0));
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list(0, 1)) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list(0, 1)) == list(0));
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list(0, 1)) == list(0, 1));
-    BOOST_HANA_STATIC_ASSERT(take(int_<3>, list(0, 1)) == list(0, 1));
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list(0, 1)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<1>, list(0, 1)) == list(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<2>, list(0, 1)) == list(0, 1));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<3>, list(0, 1)) == list(0, 1));
 }
diff --git a/test/list/instance/list/zip_with.cpp b/test/list/instance/list/zip_with.cpp
index 2c3761375..42ce5791b 100644
--- a/test/list/instance/list/zip_with.cpp
+++ b/test/list/instance/list/zip_with.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/instance.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,18 +15,18 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto plus = [](auto x, auto y) { return x + y; };
 BOOST_HANA_CONSTEXPR_LAMBDA auto inc = [](auto x) { return x + 1; };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(zip_with(inc, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(inc, list(0)) == list(1));
-    BOOST_HANA_STATIC_ASSERT(zip_with(inc, list(0, 1)) == list(1, 2));
-    BOOST_HANA_STATIC_ASSERT(zip_with(inc, list(0, 1, 2)) == list(1, 2, 3));
-    BOOST_HANA_STATIC_ASSERT(zip_with(inc, list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(inc, list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(inc, list(0)) == list(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(inc, list(0, 1)) == list(1, 2));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(inc, list(0, 1, 2)) == list(1, 2, 3));
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(inc, list(), list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(1), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(), list(3)) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(1), list(3)) == list(1 + 3));
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(1, 2), list(3, 4)) == list(1 + 3, 2 + 4));
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(1, 2, 3, 4), list(5, 6, 7)) == list(1 + 5, 2 + 6, 3 + 7));
-    BOOST_HANA_STATIC_ASSERT(zip_with(plus, list(), list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(plus, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(plus, list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(plus, list(1), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(plus, list(), list(3)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(plus, list(1), list(3)) == list(1 + 3));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(plus, list(1, 2), list(3, 4)) == list(1 + 3, 2 + 4));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(plus, list(1, 2, 3, 4), list(5, 6, 7)) == list(1 + 5, 2 + 6, 3 + 7));
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(plus, list(), list(), list()) == list());
 }
diff --git a/test/list/typeclass/applicative/ap.cpp b/test/list/typeclass/applicative/ap.cpp
index 90378556c..b3e97ccbc 100644
--- a/test/list/typeclass/applicative/ap.cpp
+++ b/test/list/typeclass/applicative/ap.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -31,20 +31,20 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using L = detail::minimal::List<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(ap(list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(ap(list(), list(x<0>)) == list());
-    BOOST_HANA_STATIC_ASSERT(ap(list(), list(x<0>, x<1>)) == list());
-    BOOST_HANA_STATIC_ASSERT(ap(list(), list(x<0>, x<1>, x<2>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(), list(x<0>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(), list(x<0>, x<1>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(), list(x<0>, x<1>, x<2>)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(ap(list(f), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(ap(list(f), list(x<0>)) == list(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(list(f), list(x<0>, x<1>)) == list(f(x<0>), f(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(ap(list(f), list(x<0>, x<1>, x<2>)) == list(f(x<0>), f(x<1>), f(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(f), list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f), list(x<0>)) == list(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f), list(x<0>, x<1>)) == list(f(x<0>), f(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f), list(x<0>, x<1>, x<2>)) == list(f(x<0>), f(x<1>), f(x<2>)));
 
-    BOOST_HANA_STATIC_ASSERT(ap(list(f, g), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(ap(list(f, g), list(x<0>)) == list(f(x<0>), g(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(list(f, g), list(x<0>, x<1>)) == list(f(x<0>), f(x<1>), g(x<0>), g(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(ap(list(f, g), list(x<0>, x<1>, x<2>)) == list(f(x<0>), f(x<1>), f(x<2>), g(x<0>), g(x<1>), g(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(ap(list(f, g), list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f, g), list(x<0>)) == list(f(x<0>), g(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f, g), list(x<0>, x<1>)) == list(f(x<0>), f(x<1>), g(x<0>), g(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(list(f, g), list(x<0>, x<1>, x<2>)) == list(f(x<0>), f(x<1>), f(x<2>), g(x<0>), g(x<1>), g(x<2>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/applicative/lift.cpp b/test/list/typeclass/applicative/lift.cpp
index 5118c2b7c..3ac71fd36 100644
--- a/test/list/typeclass/applicative/lift.cpp
+++ b/test/list/typeclass/applicative/lift.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,7 +21,7 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using L = detail::minimal::List<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(lift<L>(x<0>) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<L>(x<0>) == list(x<0>));
 }
 
 int main() {
diff --git a/test/list/typeclass/comparable/equal.cpp b/test/list/typeclass/comparable/equal.cpp
index 670331705..965bb0aeb 100644
--- a/test/list/typeclass/comparable/equal.cpp
+++ b/test/list/typeclass/comparable/equal.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,14 +20,14 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( equal(list(), list()));
-    BOOST_HANA_STATIC_ASSERT(!equal(list(x<0>), list()));
-    BOOST_HANA_STATIC_ASSERT(!equal(list(), list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( equal(list(x<0>), list(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(list(), list()));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(list(x<0>), list()));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(list(), list(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(list(x<0>), list(x<0>)));
 
-    BOOST_HANA_STATIC_ASSERT(!equal(list(x<0>, x<1>), list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( equal(list(x<0>, x<1>), list(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(list(x<0>, x<1>, x<2>, x<3>), list(x<0>, x<1>, x<2>, x<4>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(list(x<0>, x<1>), list(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(list(x<0>, x<1>), list(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(list(x<0>, x<1>, x<2>, x<3>), list(x<0>, x<1>, x<2>, x<4>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/comparable/laws.cpp b/test/list/typeclass/comparable/laws.cpp
index 8cb6fc4ac..240ea5f34 100644
--- a/test/list/typeclass/comparable/laws.cpp
+++ b/test/list/typeclass/comparable/laws.cpp
@@ -7,10 +7,10 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/list/mcd.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,7 +21,7 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         Comparable::laws::check(
             list(
                 list(),
diff --git a/test/list/typeclass/concat.cpp b/test/list/typeclass/concat.cpp
index eb28716bf..f05f2105c 100644
--- a/test/list/typeclass/concat.cpp
+++ b/test/list/typeclass/concat.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,17 +20,17 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(concat(list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(concat(list(), list(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(concat(list(), list(x<0>, x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(concat(list(), list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(), list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(), list(x<0>, x<1>)) == list(x<0>, x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>), list()) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>), list(x<1>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>), list(x<1>, x<2>)) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>), list()) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>), list(x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>), list(x<1>, x<2>)) == list(x<0>, x<1>, x<2>));
 
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>, x<1>), list()) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>, x<1>), list(x<2>)) == list(x<0>, x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(concat(list(x<0>, x<1>), list(x<2>, x<3>)) == list(x<0>, x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>, x<1>), list()) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>, x<1>), list(x<2>)) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(concat(list(x<0>, x<1>), list(x<2>, x<3>)) == list(x<0>, x<1>, x<2>, x<3>));
 }
 
 int main() {
diff --git a/test/list/typeclass/filter.cpp b/test/list/typeclass/filter.cpp
index 49d977128..a10df505a 100644
--- a/test/list/typeclass/filter.cpp
+++ b/test/list/typeclass/filter.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -28,23 +28,24 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     BOOST_HANA_CONSTEXPR_LAMBDA auto z = x<999>;
 
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(z)) == list());
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(z)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>)) == list(x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(z, x<2>)) == list(x<2>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>, z)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(z, x<2>)) == list(x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>, z)) == list(x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(z, x<2>, x<3>)) == list(x<2>, x<3>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>, z, x<3>)) == list(x<1>, x<3>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(x<1>, z, z)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(z, x<2>, z)) == list(x<2>));
-    BOOST_HANA_STATIC_ASSERT(filter(out(z), list(z, z, x<3>)) == list(x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(z, x<2>, x<3>)) == list(x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>, z, x<3>)) == list(x<1>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(x<1>, z, z)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(z, x<2>, z)) == list(x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(filter(out(z), list(z, z, x<3>)) == list(x<3>));
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)out;
 }
diff --git a/test/list/typeclass/functor/fmap.cpp b/test/list/typeclass/functor/fmap.cpp
index 427aeebed..b6dad39fb 100644
--- a/test/list/typeclass/functor/fmap.cpp
+++ b/test/list/typeclass/functor/fmap.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -26,11 +26,11 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(x<1>)) == list(f(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(x<1>, x<2>)) == list(f(x<1>), f(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(x<1>, x<2>, x<3>)) == list(f(x<1>), f(x<2>), f(x<3>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, list(x<1>, x<2>, x<3>, x<4>)) == list(f(x<1>), f(x<2>), f(x<3>), f(x<4>)));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, list(x<1>)) == list(f(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, list(x<1>, x<2>)) == list(f(x<1>), f(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, list(x<1>, x<2>, x<3>)) == list(f(x<1>), f(x<2>), f(x<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, list(x<1>, x<2>, x<3>, x<4>)) == list(f(x<1>), f(x<2>), f(x<3>), f(x<4>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/functor/laws.cpp b/test/list/typeclass/functor/laws.cpp
index 786c3e762..9de6bcbd9 100644
--- a/test/list/typeclass/functor/laws.cpp
+++ b/test/list/typeclass/functor/laws.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 
 #include <tuple>
@@ -33,7 +33,7 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(
             list(),
             list(x<0>),
diff --git a/test/list/typeclass/init.cpp b/test/list/typeclass/init.cpp
index c648477e0..10b1f5398 100644
--- a/test/list/typeclass/init.cpp
+++ b/test/list/typeclass/init.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,10 +20,10 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(init(list(x<0>)) == list());
-    BOOST_HANA_STATIC_ASSERT(init(list(x<0>, x<1>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(init(list(x<0>, x<1>, x<2>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(init(list(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(init(list(x<0>)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(x<0>, x<1>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(x<0>, x<1>, x<2>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(init(list(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, x<1>, x<2>));
 }
 
 int main() {
diff --git a/test/list/typeclass/into.cpp b/test/list/typeclass/into.cpp
index 6f394fc30..63ead1aea 100644
--- a/test/list/typeclass/into.cpp
+++ b/test/list/typeclass/into.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,11 +21,11 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using L = detail::minimal::List<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(into<L>() == list());
-    BOOST_HANA_STATIC_ASSERT(into<L>(x<0>) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(into<L>(x<0>, x<1>) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(into<L>(x<0>, x<1>, x<2>) == list(x<0>, x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(into<L>(x<0>, x<1>, x<2>, x<3>) == list(x<0>, x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(into<L>() == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(into<L>(x<0>) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(into<L>(x<0>, x<1>) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(into<L>(x<0>, x<1>, x<2>) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(into<L>(x<0>, x<1>, x<2>, x<3>) == list(x<0>, x<1>, x<2>, x<3>));
 }
 
 int main() {
diff --git a/test/list/typeclass/monad/flatten.cpp b/test/list/typeclass/monad/flatten.cpp
index 61a522b5c..2fe587704 100644
--- a/test/list/typeclass/monad/flatten.cpp
+++ b/test/list/typeclass/monad/flatten.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,11 +20,11 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(flatten(list(list(), list())) == list());
-    BOOST_HANA_STATIC_ASSERT(flatten(list(list(x<0>), list())) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(list(list(), list(x<0>))) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(list(list(x<0>), list(x<1>))) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTANT_ASSERT(flatten(list(list(), list())) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(list(list(x<0>), list())) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(list(list(), list(x<0>))) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(list(list(x<0>), list(x<1>))) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(
         flatten(list(list(x<0>, x<1>), list(), list(x<2>, x<3>), list(x<4>)))
         ==
         list(x<0>, x<1>, x<2>, x<3>, x<4>)
diff --git a/test/list/typeclass/monad/laws.cpp b/test/list/typeclass/monad/laws.cpp
index 3b50ccd7e..b8fb71c5a 100644
--- a/test/list/typeclass/monad/laws.cpp
+++ b/test/list/typeclass/monad/laws.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/monad/laws.hpp>
 
 #include <tuple>
@@ -29,10 +29,10 @@ void test() {
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto g = f;
 
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(list(), x<0>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(list(x<0>), x<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(list(x<0>, x<1>), x<2>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(list(x<0>, x<1>, x<2>), x<3>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(list(), x<0>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(list(x<0>), x<1>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(list(x<0>, x<1>), x<2>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(list(x<0>, x<1>, x<2>), x<3>, f, g));
 }
 
 int main() {
diff --git a/test/list/typeclass/partition.cpp b/test/list/typeclass/partition.cpp
index d17e5b71a..55a052064 100644
--- a/test/list/typeclass/partition.cpp
+++ b/test/list/typeclass/partition.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -30,15 +30,16 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list()) == prod(list(), list()));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<0>)) == prod(list(), list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<0>, x<1>)) == prod(list(), list(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<-1>)) == prod(list(x<-1>), list()));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<-1>, x<0>, x<2>)) == prod(list(x<-1>), list(x<0>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<0>, x<-3>, x<2>, x<-5>, x<6>)) == prod(list(x<-3>, x<-5>), list(x<0>, x<2>, x<6>)));
-    BOOST_HANA_STATIC_ASSERT(partition(neg, list(x<-1>, x<2>, x<-3>, x<0>, x<-3>, x<4>)) == prod(list(x<-1>, x<-3>, x<-3>), list(x<2>, x<0>, x<4>)));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list()) == prod(list(), list()));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<0>)) == prod(list(), list(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<0>, x<1>)) == prod(list(), list(x<0>, x<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<-1>)) == prod(list(x<-1>), list()));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<-1>, x<0>, x<2>)) == prod(list(x<-1>), list(x<0>, x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<0>, x<-3>, x<2>, x<-5>, x<6>)) == prod(list(x<-3>, x<-5>), list(x<0>, x<2>, x<6>)));
+    BOOST_HANA_CONSTANT_ASSERT(partition(neg, list(x<-1>, x<2>, x<-3>, x<0>, x<-3>, x<4>)) == prod(list(x<-1>, x<-3>, x<-3>), list(x<2>, x<0>, x<4>)));
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)neg;
 }
diff --git a/test/list/typeclass/permutations.cpp b/test/list/typeclass/permutations.cpp
index daac63b07..4389b8754 100644
--- a/test/list/typeclass/permutations.cpp
+++ b/test/list/typeclass/permutations.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -25,14 +25,15 @@ void test() {
             auto actual = permutations(xs);
             auto expected = list(expected_...);
 
-            BOOST_HANA_STATIC_ASSERT(
+            BOOST_HANA_CONSTEXPR_ASSERT(
                 length(expected) == length(actual) &&
                 all([=](auto x) { return elem(x, expected); }, actual)
             );
         };
     };
 
-    permute(list())(list());
+    BOOST_HANA_CONSTANT_ASSERT(permutations(list()) == list(list()));
+
     permute(list(x<0>))(list(x<0>));
     permute(list(x<0>, x<1>))(
         list(x<0>, x<1>),
diff --git a/test/list/typeclass/reverse.cpp b/test/list/typeclass/reverse.cpp
index e91532a68..30e32e672 100644
--- a/test/list/typeclass/reverse.cpp
+++ b/test/list/typeclass/reverse.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,10 +20,10 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(reverse(list()) == list());
-    BOOST_HANA_STATIC_ASSERT(reverse(list(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(reverse(list(x<0>, x<1>)) == list(x<1>, x<0>));
-    BOOST_HANA_STATIC_ASSERT(reverse(list(x<0>, x<1>, x<2>)) == list(x<2>, x<1>, x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(reverse(list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(reverse(list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(reverse(list(x<0>, x<1>)) == list(x<1>, x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(reverse(list(x<0>, x<1>, x<2>)) == list(x<2>, x<1>, x<0>));
 }
 
 int main() {
diff --git a/test/list/typeclass/scanl.cpp b/test/list/typeclass/scanl.cpp
index 902d86208..8e3b10c6b 100644
--- a/test/list/typeclass/scanl.cpp
+++ b/test/list/typeclass/scanl.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -27,10 +27,10 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     constexpr auto s = x<999>;
 
-    BOOST_HANA_STATIC_ASSERT(scanl(f, s, list())                 == list(s));
-    BOOST_HANA_STATIC_ASSERT(scanl(f, s, list(x<0>))             == list(s, f(s, x<0>)));
-    BOOST_HANA_STATIC_ASSERT(scanl(f, s, list(x<0>, x<1>))       == list(s, f(s, x<0>), f(f(s, x<0>), x<1>)));
-    BOOST_HANA_STATIC_ASSERT(scanl(f, s, list(x<0>, x<1>, x<2>)) == list(s, f(s, x<0>), f(f(s, x<0>), x<1>), f(f(f(s, x<0>), x<1>), x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl(f, s, list())                 == list(s));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl(f, s, list(x<0>))             == list(s, f(s, x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl(f, s, list(x<0>, x<1>))       == list(s, f(s, x<0>), f(f(s, x<0>), x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl(f, s, list(x<0>, x<1>, x<2>)) == list(s, f(s, x<0>), f(f(s, x<0>), x<1>), f(f(f(s, x<0>), x<1>), x<2>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/scanl1.cpp b/test/list/typeclass/scanl1.cpp
index b66c8adc6..48b5af33d 100644
--- a/test/list/typeclass/scanl1.cpp
+++ b/test/list/typeclass/scanl1.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -25,11 +25,11 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
-    BOOST_HANA_STATIC_ASSERT(scanl1(f, list())                       == list());
-    BOOST_HANA_STATIC_ASSERT(scanl1(f, list(x<0>))                   == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(scanl1(f, list(x<0>, x<1>))             == list(x<0>, f(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(scanl1(f, list(x<0>, x<1>, x<2>))       == list(x<0>, f(x<0>, x<1>), f(f(x<0>, x<1>), x<2>)));
-    BOOST_HANA_STATIC_ASSERT(scanl1(f, list(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, f(x<0>, x<1>), f(f(x<0>, x<1>), x<2>), f(f(f(x<0>, x<1>), x<2>), x<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(scanl1(f, list())                        == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl1(f, list(x<0>))                   == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl1(f, list(x<0>, x<1>))             == list(x<0>, f(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl1(f, list(x<0>, x<1>, x<2>))       == list(x<0>, f(x<0>, x<1>), f(f(x<0>, x<1>), x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanl1(f, list(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, f(x<0>, x<1>), f(f(x<0>, x<1>), x<2>), f(f(f(x<0>, x<1>), x<2>), x<3>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/scanr.cpp b/test/list/typeclass/scanr.cpp
index 5be3b1e43..59639d575 100644
--- a/test/list/typeclass/scanr.cpp
+++ b/test/list/typeclass/scanr.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -27,10 +27,10 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     constexpr auto s = x<999>;
 
-    BOOST_HANA_STATIC_ASSERT(scanr(f, s, list())                 == list(                                                               s));
-    BOOST_HANA_STATIC_ASSERT(scanr(f, s, list(x<0>))             == list(                                                   f(x<0>, s), s));
-    BOOST_HANA_STATIC_ASSERT(scanr(f, s, list(x<0>, x<1>))       == list(                              f(x<0>, f(x<1>, s)), f(x<1>, s), s));
-    BOOST_HANA_STATIC_ASSERT(scanr(f, s, list(x<0>, x<1>, x<2>)) == list(f(x<0>, f(x<1>, f(x<2>, s))), f(x<1>, f(x<2>, s)), f(x<2>, s), s));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr(f, s, list())                 == list(                                                               s));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr(f, s, list(x<0>))             == list(                                                   f(x<0>, s), s));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr(f, s, list(x<0>, x<1>))       == list(                              f(x<0>, f(x<1>, s)), f(x<1>, s), s));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr(f, s, list(x<0>, x<1>, x<2>)) == list(f(x<0>, f(x<1>, f(x<2>, s))), f(x<1>, f(x<2>, s)), f(x<2>, s), s));
 }
 
 int main() {
diff --git a/test/list/typeclass/scanr1.cpp b/test/list/typeclass/scanr1.cpp
index 73b94712d..3d4c5d7b0 100644
--- a/test/list/typeclass/scanr1.cpp
+++ b/test/list/typeclass/scanr1.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -25,10 +25,10 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
-    BOOST_HANA_STATIC_ASSERT(scanr1(f, list())                 == list(                                           ));
-    BOOST_HANA_STATIC_ASSERT(scanr1(f, list(x<0>))             == list(                                       x<0>));
-    BOOST_HANA_STATIC_ASSERT(scanr1(f, list(x<0>, x<1>))       == list(                        f(x<0>, x<1>), x<1>));
-    BOOST_HANA_STATIC_ASSERT(scanr1(f, list(x<0>, x<1>, x<2>)) == list(f(x<0>, f(x<1>, x<2>)), f(x<1>, x<2>), x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(scanr1(f, list())                  == list(                                           ));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr1(f, list(x<0>))             == list(                                       x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr1(f, list(x<0>, x<1>))       == list(                        f(x<0>, x<1>), x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(scanr1(f, list(x<0>, x<1>, x<2>)) == list(f(x<0>, f(x<1>, x<2>)), f(x<1>, x<2>), x<2>));
 }
 
 int main() {
diff --git a/test/list/typeclass/searchable/any.cpp b/test/list/typeclass/searchable/any.cpp
index f00e304c1..13c68d2cf 100644
--- a/test/list/typeclass/searchable/any.cpp
+++ b/test/list/typeclass/searchable/any.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -25,24 +25,25 @@ void test() {
 
     constexpr struct { } invalid{};
 
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<9>), list()));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<9>), list()));
 
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<9>), list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<0>), list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<0>), list(x<0>, invalid)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<0>), list(x<0>, invalid, invalid)));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<9>), list(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<0>), list(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<0>), list(x<0>, invalid)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<0>), list(x<0>, invalid, invalid)));
 
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<9>), list(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<1>), list(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<1>), list(x<0>, x<1>, invalid)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<1>), list(x<0>, x<1>, invalid, invalid)));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<9>), list(x<0>, x<1>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<1>), list(x<0>, x<1>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<1>), list(x<0>, x<1>, invalid)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<1>), list(x<0>, x<1>, invalid, invalid)));
 
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<9>), list(x<0>, x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>, nothing)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>, nothing, nothing)));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<9>), list(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>, nothing)));
+    BOOST_HANA_CONSTANT_ASSERT( any(is(x<2>), list(x<0>, x<1>, x<2>, nothing, nothing)));
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)is;
 }
diff --git a/test/list/typeclass/searchable/find.cpp b/test/list/typeclass/searchable/find.cpp
index 8664308ec..00765da8b 100644
--- a/test/list/typeclass/searchable/find.cpp
+++ b/test/list/typeclass/searchable/find.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -26,24 +26,25 @@ void test() {
 
     constexpr struct { } invalid{};
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<9>), list()) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<9>), list()) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<9>), list(x<0>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), list(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), list(x<0>, invalid)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), list(x<0>, invalid, invalid)) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<9>), list(x<0>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), list(x<0>)) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), list(x<0>, invalid)) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), list(x<0>, invalid, invalid)) == just(x<0>));
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<9>), list(x<0>, x<1>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), list(x<0>, x<1>)) == just(x<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), list(x<0>, x<1>, invalid)) == just(x<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), list(x<0>, x<1>, invalid, invalid)) == just(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<9>), list(x<0>, x<1>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), list(x<0>, x<1>)) == just(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), list(x<0>, x<1>, invalid)) == just(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), list(x<0>, x<1>, invalid, invalid)) == just(x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<9>), list(x<0>, x<1>, x<2>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>)) == just(x<2>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>, nothing)) == just(x<2>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>, nothing, nothing)) == just(x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<9>), list(x<0>, x<1>, x<2>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>)) == just(x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>, nothing)) == just(x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<2>), list(x<0>, x<1>, x<2>, nothing, nothing)) == just(x<2>));
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)is;
 }
\ No newline at end of file
diff --git a/test/list/typeclass/snoc.cpp b/test/list/typeclass/snoc.cpp
index edcff31d6..5f29511b1 100644
--- a/test/list/typeclass/snoc.cpp
+++ b/test/list/typeclass/snoc.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,9 +20,9 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(snoc(list(), x<0>) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(snoc(list(x<0>), x<1>) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(snoc(list(x<0>, x<1>), x<2>) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(), x<0>) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(x<0>), x<1>) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(snoc(list(x<0>, x<1>), x<2>) == list(x<0>, x<1>, x<2>));
 }
 
 int main() {
diff --git a/test/list/typeclass/sort.cpp b/test/list/typeclass/sort.cpp
index a213ff54c..c2a437e74 100644
--- a/test/list/typeclass/sort.cpp
+++ b/test/list/typeclass/sort.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -23,12 +23,12 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(sort(list()) == list());
-    BOOST_HANA_STATIC_ASSERT(sort(list(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(sort(list(x<0>, x<1>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(sort(list(x<1>, x<0>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(sort(list(x<1>, x<0>, x<4>, x<2>)) == list(x<0>, x<1>, x<2>, x<4>));
-    BOOST_HANA_STATIC_ASSERT(sort(list(x<1>, x<0>, x<-4>, x<2>)) == list(x<-4>, x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(sort(list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(sort(list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(sort(list(x<0>, x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(sort(list(x<1>, x<0>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(sort(list(x<1>, x<0>, x<4>, x<2>)) == list(x<0>, x<1>, x<2>, x<4>));
+    BOOST_HANA_CONSTANT_ASSERT(sort(list(x<1>, x<0>, x<-4>, x<2>)) == list(x<-4>, x<0>, x<1>, x<2>));
 }
 
 int main() {
diff --git a/test/list/typeclass/sort_by.cpp b/test/list/typeclass/sort_by.cpp
index 0ace4981a..0d9615e97 100644
--- a/test/list/typeclass/sort_by.cpp
+++ b/test/list/typeclass/sort_by.cpp
@@ -8,9 +8,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/bool.hpp>
 #include <boost/hana/comparable/equal_mcd.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -42,7 +42,7 @@ constexpr struct _predicate {
 
 BOOST_HANA_CONSTEXPR_LAMBDA auto check = [](auto sorted_list) {
     auto perms = fmap(partial(sort_by, pred), permutations(sorted_list));
-    BOOST_HANA_STATIC_ASSERT(all(_ == sorted_list, perms));
+    BOOST_HANA_CONSTANT_ASSERT(all(_ == sorted_list, perms));
 };
 
 template <typename mcd>
@@ -55,15 +55,15 @@ void test() {
     check(list(x<1>, x<2>, x<3>));
 
     // check stability
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(x<1>, y<1>)) == list(x<1>, y<1>));
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(y<1>, x<1>)) == list(y<1>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(x<1>, y<1>)) == list(x<1>, y<1>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(y<1>, x<1>)) == list(y<1>, x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(x<1>, y<1>, x<2>, y<2>)) == list(x<1>, y<1>, x<2>, y<2>));
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(x<1>, x<2>, y<1>, y<2>)) == list(x<1>, y<1>, x<2>, y<2>));
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(y<1>, x<1>, x<2>, y<2>)) == list(y<1>, x<1>, x<2>, y<2>));
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(x<2>, y<1>, y<2>, x<1>)) == list(y<1>, x<1>, x<2>, y<2>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(x<1>, y<1>, x<2>, y<2>)) == list(x<1>, y<1>, x<2>, y<2>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(x<1>, x<2>, y<1>, y<2>)) == list(x<1>, y<1>, x<2>, y<2>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(y<1>, x<1>, x<2>, y<2>)) == list(y<1>, x<1>, x<2>, y<2>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(x<2>, y<1>, y<2>, x<1>)) == list(y<1>, x<1>, x<2>, y<2>));
 
-    BOOST_HANA_STATIC_ASSERT(sort_by(pred, list(x<1>, x<3>, y<1>, x<2>, y<3>)) == list(x<1>, y<1>, x<2>, x<3>, y<3>));
+    BOOST_HANA_CONSTANT_ASSERT(sort_by(pred, list(x<1>, x<3>, y<1>, x<2>, y<3>)) == list(x<1>, y<1>, x<2>, x<3>, y<3>));
 }
 
 int main() {
diff --git a/test/list/typeclass/take.cpp b/test/list/typeclass/take.cpp
index f27fc7e0a..ab0ac04d4 100644
--- a/test/list/typeclass/take.cpp
+++ b/test/list/typeclass/take.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -21,19 +21,19 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<1>, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<2>, list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list(x<0>)) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(take(int_<3>, list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list(x<0>)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<1>, list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<2>, list(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<3>, list(x<0>)) == list(x<0>));
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<0>, list(x<0>, x<1>)) == list());
-    BOOST_HANA_STATIC_ASSERT(take(int_<1>, list(x<0>, x<1>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, list(x<0>, x<1>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(take(int_<3>, list(x<0>, x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take(int_<0>, list(x<0>, x<1>)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<1>, list(x<0>, x<1>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<2>, list(x<0>, x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<3>, list(x<0>, x<1>)) == list(x<0>, x<1>));
 }
 
 int main() {
diff --git a/test/list/typeclass/take_until.cpp b/test/list/typeclass/take_until.cpp
index bc6dc310f..e12af38cf 100644
--- a/test/list/typeclass/take_until.cpp
+++ b/test/list/typeclass/take_until.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -28,21 +28,22 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     constexpr auto z = x<999>;
 
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(z)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(z)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>, z)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(z, x<2>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>, z)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(z, x<2>)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>, x<2>, x<3>)) == list(x<1>, x<2>, x<3>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(x<1>, z, x<3>)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_until(is(z), list(z, x<2>, x<3>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>, x<2>, x<3>)) == list(x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(x<1>, z, x<3>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_until(is(z), list(z, x<2>, x<3>)) == list());
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)is;
 }
diff --git a/test/list/typeclass/take_while.cpp b/test/list/typeclass/take_while.cpp
index bdcd0b7a4..d98b468fc 100644
--- a/test/list/typeclass/take_while.cpp
+++ b/test/list/typeclass/take_while.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
@@ -28,21 +28,22 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     constexpr auto z = x<999>;
 
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list()) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(z)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(z)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>, z)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(z, x<2>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>, x<2>)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>, z)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(z, x<2>)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>, x<2>, x<3>)) == list(x<1>, x<2>, x<3>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(x<1>, z, x<3>)) == list(x<1>));
-    BOOST_HANA_STATIC_ASSERT(take_while(isnt(z), list(z, x<2>, x<3>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>, x<2>, x<3>)) == list(x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>, x<2>, z)) == list(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(x<1>, z, x<3>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(take_while(isnt(z), list(z, x<2>, x<3>)) == list());
 }
 
 int main() {
     test<List::mcd<void>>();
+    (void)isnt;
 }
diff --git a/test/list/typeclass/to.cpp b/test/list/typeclass/to.cpp
index 569be7cf9..ddce1d241 100644
--- a/test/list/typeclass/to.cpp
+++ b/test/list/typeclass/to.cpp
@@ -6,11 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/foldable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -24,11 +24,11 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using L = detail::minimal::List<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(to<L>(foldable()) == list());
-    BOOST_HANA_STATIC_ASSERT(to<L>(foldable(x<0>)) == list(x<0>));
-    BOOST_HANA_STATIC_ASSERT(to<L>(foldable(x<0>, x<1>)) == list(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(to<L>(foldable(x<0>, x<1>, x<2>)) == list(x<0>, x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(to<L>(foldable(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(to<L>(foldable()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(foldable(x<0>)) == list(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(foldable(x<0>, x<1>)) == list(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(foldable(x<0>, x<1>, x<2>)) == list(x<0>, x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(foldable(x<0>, x<1>, x<2>, x<3>)) == list(x<0>, x<1>, x<2>, x<3>));
 }
 
 int main() {
diff --git a/test/list/typeclass/traversable/sequence.cpp b/test/list/typeclass/traversable/sequence.cpp
index c164d78b6..5fcedecc4 100644
--- a/test/list/typeclass/traversable/sequence.cpp
+++ b/test/list/typeclass/traversable/sequence.cpp
@@ -6,11 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -24,10 +24,10 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using A = detail::minimal::Applicative<>;
 
-    BOOST_HANA_STATIC_ASSERT(sequence<A>(list()) == applicative(list()));
-    BOOST_HANA_STATIC_ASSERT(sequence<A>(list(applicative(x<0>))) == applicative(list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(sequence<A>(list(applicative(x<0>), applicative(x<1>))) == applicative(list(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(sequence<A>(list(applicative(x<0>), applicative(x<1>), applicative(x<2>))) == applicative(list(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(sequence<A>(list()) == applicative(list()));
+    BOOST_HANA_CONSTEXPR_ASSERT(sequence<A>(list(applicative(x<0>))) == applicative(list(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(sequence<A>(list(applicative(x<0>), applicative(x<1>))) == applicative(list(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(sequence<A>(list(applicative(x<0>), applicative(x<1>), applicative(x<2>))) == applicative(list(x<0>, x<1>, x<2>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/traversable/traverse.cpp b/test/list/typeclass/traversable/traverse.cpp
index a37fb7a4c..022d3f4bc 100644
--- a/test/list/typeclass/traversable/traverse.cpp
+++ b/test/list/typeclass/traversable/traverse.cpp
@@ -6,11 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -34,11 +34,11 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     using A = detail::minimal::Applicative<>;
 
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, list()) == applicative(list()));
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, list(x<0>)) == applicative(list(g(x<0>))));
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, list(x<0>, x<1>)) == applicative(list(g(x<0>), g(x<1>))));
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, list(x<0>, x<1>, x<2>)) == applicative(list(g(x<0>), g(x<1>), g(x<2>))));
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, list(x<0>, x<1>, x<2>, x<3>)) == applicative(list(g(x<0>), g(x<1>), g(x<2>), g(x<3>))));
+    BOOST_HANA_CONSTANT_ASSERT(traverse<A>(f, list()) == applicative(list()));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<A>(f, list(x<0>)) == applicative(list(g(x<0>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<A>(f, list(x<0>, x<1>)) == applicative(list(g(x<0>), g(x<1>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<A>(f, list(x<0>, x<1>, x<2>)) == applicative(list(g(x<0>), g(x<1>), g(x<2>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<A>(f, list(x<0>, x<1>, x<2>, x<3>)) == applicative(list(g(x<0>), g(x<1>), g(x<2>), g(x<3>))));
 }
 
 int main() {
diff --git a/test/list/typeclass/unfoldl.cpp b/test/list/typeclass/unfoldl.cpp
index da84f4f0c..8ed9c3b8e 100644
--- a/test/list/typeclass/unfoldl.cpp
+++ b/test/list/typeclass/unfoldl.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 
@@ -41,11 +41,11 @@ void test() {
         };
     };
 
-    BOOST_HANA_STATIC_ASSERT(unfoldl<L>(stop_at(x<0>), x<0>) == list());
-    BOOST_HANA_STATIC_ASSERT(unfoldl<L>(stop_at(x<1>), x<0>) == list(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldl<L>(stop_at(x<2>), x<0>) == list(f(x<1>), f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldl<L>(stop_at(x<3>), x<0>) == list(f(x<2>), f(x<1>), f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldl<L>(stop_at(x<4>), x<0>) == list(f(x<3>), f(x<2>), f(x<1>), f(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(unfoldl<L>(stop_at(x<0>), x<0>) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldl<L>(stop_at(x<1>), x<0>) == list(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldl<L>(stop_at(x<2>), x<0>) == list(f(x<1>), f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldl<L>(stop_at(x<3>), x<0>) == list(f(x<2>), f(x<1>), f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldl<L>(stop_at(x<4>), x<0>) == list(f(x<3>), f(x<2>), f(x<1>), f(x<0>)));
 }
 
 // Make sure it can revert foldl under some conditions
@@ -61,15 +61,15 @@ void test_revert() {
     };
 
     // Make sure the special conditions are met
-    BOOST_HANA_STATIC_ASSERT(g(z) == nothing);
-    BOOST_HANA_STATIC_ASSERT(g(f(z, x<0>)) == just(prod(z, x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(g(z) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(g(f(z, x<0>)) == just(prod(z, x<0>)));
 
     // Make sure the reversing works
     auto lists = list(
         list(), list(x<0>), list(x<0>, x<1>), list(x<0>, x<1>, x<2>)
     );
     for_each(lists, [=](auto xs) {
-        BOOST_HANA_STATIC_ASSERT(unfoldl<L>(g, foldl(f, z, xs)) == xs);
+        BOOST_HANA_CONSTANT_ASSERT(unfoldl<L>(g, foldl(f, z, xs)) == xs);
     });
 }
 
diff --git a/test/list/typeclass/unfoldr.cpp b/test/list/typeclass/unfoldr.cpp
index 740e3a891..667d8b27d 100644
--- a/test/list/typeclass/unfoldr.cpp
+++ b/test/list/typeclass/unfoldr.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 
@@ -41,11 +41,11 @@ void test() {
         };
     };
 
-    BOOST_HANA_STATIC_ASSERT(unfoldr<L>(stop_at(x<0>), x<0>) == list());
-    BOOST_HANA_STATIC_ASSERT(unfoldr<L>(stop_at(x<1>), x<0>) == list(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldr<L>(stop_at(x<2>), x<0>) == list(f(x<0>), f(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldr<L>(stop_at(x<3>), x<0>) == list(f(x<0>), f(x<1>), f(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(unfoldr<L>(stop_at(x<4>), x<0>) == list(f(x<0>), f(x<1>), f(x<2>), f(x<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(unfoldr<L>(stop_at(x<0>), x<0>) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldr<L>(stop_at(x<1>), x<0>) == list(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldr<L>(stop_at(x<2>), x<0>) == list(f(x<0>), f(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldr<L>(stop_at(x<3>), x<0>) == list(f(x<0>), f(x<1>), f(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unfoldr<L>(stop_at(x<4>), x<0>) == list(f(x<0>), f(x<1>), f(x<2>), f(x<3>)));
 }
 
 // Make sure it can revert foldr under some conditions
@@ -61,15 +61,15 @@ void test_revert() {
     };
 
     // Make sure the special conditions are met
-    BOOST_HANA_STATIC_ASSERT(g(z) == nothing);
-    BOOST_HANA_STATIC_ASSERT(g(f(x<0>, z)) == just(prod(x<0>, z)));
+    BOOST_HANA_CONSTANT_ASSERT(g(z) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(g(f(x<0>, z)) == just(prod(x<0>, z)));
 
     // Make sure the reversing works
     auto lists = list(
         list(), list(x<0>), list(x<0>, x<1>), list(x<0>, x<1>, x<2>)
     );
     for_each(lists, [=](auto xs) {
-        BOOST_HANA_STATIC_ASSERT(unfoldr<L>(g, foldr(f, z, xs)) == xs);
+        BOOST_HANA_CONSTANT_ASSERT(unfoldr<L>(g, foldr(f, z, xs)) == xs);
     });
 }
 
diff --git a/test/list/typeclass/unzip.cpp b/test/list/typeclass/unzip.cpp
index 91d7963c1..33e148a10 100644
--- a/test/list/typeclass/unzip.cpp
+++ b/test/list/typeclass/unzip.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,21 +21,21 @@ void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
     auto p = list; // tests are unreadable otherwise. mnemonic: pair
 
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p())) == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p())) == list());
 
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(), p())) == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>, x<2>), p(x<1>, x<3>, x<4>))) == list(p(x<0>, x<1>), p(x<2>, x<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(), p())) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(unzip(list(p(x<0>, x<2>), p(x<1>, x<3>, x<4>))) == list(p(x<0>, x<1>), p(x<2>, x<3>)));
 
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(),     p(),     p()))     == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>), p(),     p()))     == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(),     p(x<1>), p()))     == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(),     p(),     p(x<2>))) == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>), p(x<1>), p()))     == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(),     p(x<1>), p(x<2>))) == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>), p(),     p(x<2>))) == list());
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>), p(x<1>), p(x<2>))) == list(p(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(),     p(),     p()))     == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(x<0>), p(),     p()))     == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(),     p(x<1>), p()))     == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(),     p(),     p(x<2>))) == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(x<0>), p(x<1>), p()))     == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(),     p(x<1>), p(x<2>))) == list());
+    BOOST_HANA_CONSTANT_ASSERT(unzip(list(p(x<0>), p(),     p(x<2>))) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(unzip(list(p(x<0>), p(x<1>), p(x<2>))) == list(p(x<0>, x<1>, x<2>)));
 
-    BOOST_HANA_STATIC_ASSERT(unzip(list(p(x<0>, x<3>), p(x<1>, x<4>), p(x<2>, x<5>))) == list(p(x<0>, x<1>, x<2>), p(x<3>, x<4>, x<5>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(unzip(list(p(x<0>, x<3>), p(x<1>, x<4>), p(x<2>, x<5>))) == list(p(x<0>, x<1>, x<2>), p(x<3>, x<4>, x<5>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/zip.cpp b/test/list/typeclass/zip.cpp
index 65c3392b5..c07fb6e96 100644
--- a/test/list/typeclass/zip.cpp
+++ b/test/list/typeclass/zip.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,16 +20,16 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(zip(list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>)) == list(list(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>, x<1>)) == list(list(x<0>), list(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>, x<1>, x<2>)) == list(list(x<0>), list(x<1>), list(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(zip(list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>)) == list(list(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>, x<1>)) == list(list(x<0>), list(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>, x<1>, x<2>)) == list(list(x<0>), list(x<1>), list(x<2>)));
 
-    BOOST_HANA_STATIC_ASSERT(zip(list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>), list(x<1>)) == list(list(x<0>, x<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(zip(list(), list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>), list(x<1>)) == list(list(x<0>, x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>), list(x<1>), list(x<2>)) == list(list(x<0>, x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT(zip(list(x<0>, x<3>), list(x<1>, x<4>), list(x<2>, x<5>, x<8>)) == list(list(x<0>, x<1>, x<2>), list(x<3>, x<4>, x<5>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>), list(x<1>), list(x<2>)) == list(list(x<0>, x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip(list(x<0>, x<3>), list(x<1>, x<4>), list(x<2>, x<5>, x<8>)) == list(list(x<0>, x<1>, x<2>), list(x<3>, x<4>, x<5>)));
 }
 
 int main() {
diff --git a/test/list/typeclass/zip_with.cpp b/test/list/typeclass/zip_with.cpp
index ffeacbdc5..277b47389 100644
--- a/test/list/typeclass/zip_with.cpp
+++ b/test/list/typeclass/zip_with.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/list/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -34,25 +34,25 @@ template <typename mcd>
 void test() {
     BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list(x<0>)) == list(f1(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list(x<0>, x<1>)) == list(f1(x<0>), f1(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list(x<0>, x<1>, x<2>)) == list(f1(x<0>), f1(x<1>), f1(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f1, list(), list(x<1>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f1, list()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f1, list(x<0>)) == list(f1(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f1, list(x<0>, x<1>)) == list(f1(x<0>), f1(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f1, list(x<0>, x<1>, x<2>)) == list(f1(x<0>), f1(x<1>), f1(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f1, list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f1, list(), list(x<1>)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(x<0>), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(), list(x<0>)) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(x<0>), list(x<1>)) == list(f2(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(x<0>, x<1>), list(x<2>, x<3>)) == list(f2(x<0>, x<2>), f2(x<1>, x<3>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(x<1>, x<2>, x<3>, x<4>), list(x<5>, x<6>, x<7>)) == list(f2(x<1>, x<5>), f2(x<2>, x<6>), f2(x<3>, x<7>)));
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(), list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(), list(), list(x<1>)) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(f2, list(), list(x<1>), list(x<2>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(x<0>), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(), list(x<0>)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f2, list(x<0>), list(x<1>)) == list(f2(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f2, list(x<0>, x<1>), list(x<2>, x<3>)) == list(f2(x<0>, x<2>), f2(x<1>, x<3>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(zip_with(f2, list(x<1>, x<2>, x<3>, x<4>), list(x<5>, x<6>, x<7>)) == list(f2(x<1>, x<5>), f2(x<2>, x<6>), f2(x<3>, x<7>)));
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(), list(), list()) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(), list(), list(x<1>)) == list());
+    BOOST_HANA_CONSTANT_ASSERT(zip_with(f2, list(), list(x<1>), list(x<2>)) == list());
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         zip_with(fn,
             list(x<11>, x<12>, x<13>, x<14>),
             list(x<21>, x<22>, x<23>),
diff --git a/test/logical/and.cpp b/test/logical/and.cpp
index a7d1872fe..f059fc201 100644
--- a/test/logical/and.cpp
+++ b/test/logical/and.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/logical/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/logical.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -17,23 +17,23 @@ template <typename mcd>
 void test() {
     constexpr auto logical = detail::minimal::logical<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(and_(logical(true)) == logical(true));
-    BOOST_HANA_STATIC_ASSERT(and_(logical(false)) == logical(false));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true)) == logical(true));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(false)) == logical(false));
 
-    BOOST_HANA_STATIC_ASSERT(and_(logical(true), logical(true)) == logical(true));
-    BOOST_HANA_STATIC_ASSERT(and_(logical(true), logical(false)) == logical(false));
-    // BOOST_HANA_STATIC_ASSERT(!and_(logical(false), invalid));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true), logical(true)) == logical(true));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true), logical(false)) == logical(false));
+    // BOOST_HANA_CONSTEXPR_ASSERT(!and_(logical(false), invalid));
 
-    BOOST_HANA_STATIC_ASSERT(and_(logical(true), logical(true), logical(true)) == logical(true));
-    BOOST_HANA_STATIC_ASSERT(and_(logical(true), logical(true), logical(false)) == logical(false));
-    // BOOST_HANA_STATIC_ASSERT(and_(logical(true), logical(false), invalid) == logical(false));
-    // BOOST_HANA_STATIC_ASSERT(!and_(logical(false), invalid, invalid));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true), logical(true), logical(true)) == logical(true));
+    BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true), logical(true), logical(false)) == logical(false));
+    // BOOST_HANA_CONSTEXPR_ASSERT(and_(logical(true), logical(false), invalid) == logical(false));
+    // BOOST_HANA_CONSTEXPR_ASSERT(!and_(logical(false), invalid, invalid));
 
     // operators
-    BOOST_HANA_STATIC_ASSERT((logical(true) && logical(true)) == and_(logical(true), logical(true)));
-    BOOST_HANA_STATIC_ASSERT((logical(true) && logical(false)) == and_(logical(true), logical(false)));
-    BOOST_HANA_STATIC_ASSERT((logical(false) && logical(true)) == and_(logical(false), logical(true)));
-    BOOST_HANA_STATIC_ASSERT((logical(false) && logical(false)) == and_(logical(false), logical(false)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(true) && logical(true)) == and_(logical(true), logical(true)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(true) && logical(false)) == and_(logical(true), logical(false)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(false) && logical(true)) == and_(logical(false), logical(true)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(false) && logical(false)) == and_(logical(false), logical(false)));
 }
 
 int main() {
diff --git a/test/logical/if.cpp b/test/logical/if.cpp
index 9cf30cfe0..b855f01fc 100644
--- a/test/logical/if.cpp
+++ b/test/logical/if.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/logical/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/logical.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -19,8 +19,8 @@ template <typename mcd>
 void test() {
     constexpr auto logical = detail::minimal::logical<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(if_(logical(true), x<0>, x<1>) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(if_(logical(false), x<0>, x<1>) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(if_(logical(true), x<0>, x<1>) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(if_(logical(false), x<0>, x<1>) == x<1>);
 }
 
 int main() {
diff --git a/test/logical/not.cpp b/test/logical/not.cpp
index 455816e87..14bb139f5 100644
--- a/test/logical/not.cpp
+++ b/test/logical/not.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/logical/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/logical.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,11 +15,11 @@ template <typename mcd>
 void test() {
     constexpr auto logical = detail::minimal::logical<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(not_(logical(true)) == logical(false));
-    BOOST_HANA_STATIC_ASSERT(not_(logical(false)) == logical(true));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(logical(true)) == logical(false));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(logical(false)) == logical(true));
 
-    BOOST_HANA_STATIC_ASSERT(!logical(true) == not_(logical(true)));
-    BOOST_HANA_STATIC_ASSERT(!logical(false) == not_(logical(false)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!logical(true) == not_(logical(true)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!logical(false) == not_(logical(false)));
 }
 
 int main() {
diff --git a/test/logical/or.cpp b/test/logical/or.cpp
index 880ebc998..339af6fd5 100644
--- a/test/logical/or.cpp
+++ b/test/logical/or.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/logical/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/logical.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -17,23 +17,23 @@ template <typename mcd>
 void test() {
     constexpr auto logical = detail::minimal::logical<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(or_(logical(true)) == logical(true));
-    BOOST_HANA_STATIC_ASSERT(or_(logical(false)) == logical(false));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(true)) == logical(true));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false)) == logical(false));
 
-    BOOST_HANA_STATIC_ASSERT(or_(logical(false), logical(false)) == logical(false));
-    BOOST_HANA_STATIC_ASSERT(or_(logical(false), logical(true)) == logical(true));
-    // BOOST_HANA_STATIC_ASSERT(or_(logical(true), invalid));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false), logical(false)) == logical(false));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false), logical(true)) == logical(true));
+    // BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(true), invalid));
 
-    BOOST_HANA_STATIC_ASSERT(or_(logical(false), logical(false), logical(false)) == logical(false));
-    BOOST_HANA_STATIC_ASSERT(or_(logical(false), logical(false), logical(true)) == logical(true));
-    // BOOST_HANA_STATIC_ASSERT(or_(logical(false), logical(true), invalid));
-    // BOOST_HANA_STATIC_ASSERT(or_(logical(true), invalid, invalid));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false), logical(false), logical(false)) == logical(false));
+    BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false), logical(false), logical(true)) == logical(true));
+    // BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(false), logical(true), invalid));
+    // BOOST_HANA_CONSTEXPR_ASSERT(or_(logical(true), invalid, invalid));
 
     // operators
-    BOOST_HANA_STATIC_ASSERT((logical(true) || logical(true)) == or_(logical(true), logical(true)));
-    BOOST_HANA_STATIC_ASSERT((logical(true) || logical(false)) == or_(logical(true), logical(false)));
-    BOOST_HANA_STATIC_ASSERT((logical(false) || logical(true)) == or_(logical(false), logical(true)));
-    BOOST_HANA_STATIC_ASSERT((logical(false) || logical(false)) == or_(logical(false), logical(false)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(true) || logical(true)) == or_(logical(true), logical(true)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(true) || logical(false)) == or_(logical(true), logical(false)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(false) || logical(true)) == or_(logical(false), logical(true)));
+    BOOST_HANA_CONSTEXPR_ASSERT((logical(false) || logical(false)) == or_(logical(false), logical(false)));
 }
 
 int main() {
diff --git a/test/map/comparable/equal.cpp b/test/map/comparable/equal.cpp
index a378bd576..b281a4aeb 100644
--- a/test/map/comparable/equal.cpp
+++ b/test/map/comparable/equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -22,20 +22,20 @@ template <int i, int j>
 constexpr auto p = detail::minimal::product<>(key<i>, value<j>);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(map(), map()));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>), map()));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(), map(p<1, 1>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(map(), map()));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>), map()));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(), map(p<1, 1>)));
 
-    BOOST_HANA_STATIC_ASSERT( equal(map(p<1, 1>), map(p<1, 1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>), map(p<1, 2>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>), map(p<2, 1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>), map(p<1, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(map(p<1, 1>), map(p<1, 1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>), map(p<1, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>), map(p<2, 1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>), map(p<1, 1>, p<2, 2>)));
 
-    BOOST_HANA_STATIC_ASSERT( equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 2>)));
-    BOOST_HANA_STATIC_ASSERT( equal(map(p<1, 1>, p<2, 2>), map(p<2, 2>, p<1, 1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<9, 1>, p<2, 2>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 9>, p<2, 2>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<9, 2>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 9>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 2>, p<3, 3>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(map(p<1, 1>, p<2, 2>), map(p<2, 2>, p<1, 1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<9, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 9>, p<2, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<9, 2>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 9>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(map(p<1, 1>, p<2, 2>), map(p<1, 1>, p<2, 2>, p<3, 3>)));
 }
diff --git a/test/map/comparable/laws.cpp b/test/map/comparable/laws.cpp
index f7453865a..22485b550 100644
--- a/test/map/comparable/laws.cpp
+++ b/test/map/comparable/laws.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/map.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -25,7 +25,7 @@ template <int i, int j>
 BOOST_HANA_CONSTEXPR_LAMBDA auto p = detail::minimal::product<>(key<i>, value<j>);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Comparable::laws::check(
         list(
             map(),
             map(p<1, 1>),
diff --git a/test/map/from_list.cpp b/test/map/from_list.cpp
index e2ade900a..1fb2f5977 100644
--- a/test/map/from_list.cpp
+++ b/test/map/from_list.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -26,8 +26,8 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto p = detail::minimal::product<>(key<i>, value<j>
 int main() {
     constexpr auto list = detail::minimal::list<>;
 
-    BOOST_HANA_STATIC_ASSERT(to<Map>(list()) == map());
-    BOOST_HANA_STATIC_ASSERT(to<Map>(list(p<1, 1>)) == map(p<1, 1>));
-    BOOST_HANA_STATIC_ASSERT(to<Map>(list(p<1, 1>, p<2, 2>)) == map(p<1, 1>, p<2, 2>));
-    BOOST_HANA_STATIC_ASSERT(to<Map>(list(p<1, 1>, p<2, 2>, p<3, 3>)) == map(p<1, 1>, p<2, 2>, p<3, 3>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Map>(list()) == map());
+    BOOST_HANA_CONSTANT_ASSERT(to<Map>(list(p<1, 1>)) == map(p<1, 1>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Map>(list(p<1, 1>, p<2, 2>)) == map(p<1, 1>, p<2, 2>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Map>(list(p<1, 1>, p<2, 2>, p<3, 3>)) == map(p<1, 1>, p<2, 2>, p<3, 3>));
 }
diff --git a/test/map/keys.cpp b/test/map/keys.cpp
index 0d378b6bd..f851e623e 100644
--- a/test/map/keys.cpp
+++ b/test/map/keys.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -24,8 +24,8 @@ template <int i, int j>
 BOOST_HANA_CONSTEXPR_LAMBDA auto p = detail::minimal::product<>(key<i>, value<j>);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(keys(map()) == list());
-    BOOST_HANA_STATIC_ASSERT(keys(map(p<1, 1>)) == list(key<1>));
-    BOOST_HANA_STATIC_ASSERT(keys(map(p<1, 1>, p<2, 2>)) == list(key<1>, key<2>));
-    BOOST_HANA_STATIC_ASSERT(keys(map(p<1, 1>, p<2, 2>, p<3, 3>)) == list(key<1>, key<2>, key<3>));
+    BOOST_HANA_CONSTANT_ASSERT(keys(map()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(keys(map(p<1, 1>)) == list(key<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(keys(map(p<1, 1>, p<2, 2>)) == list(key<1>, key<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(keys(map(p<1, 1>, p<2, 2>, p<3, 3>)) == list(key<1>, key<2>, key<3>));
 }
diff --git a/test/map/searchable/any.cpp b/test/map/searchable/any.cpp
index 9b7aba1bf..971912156 100644
--- a/test/map/searchable/any.cpp
+++ b/test/map/searchable/any.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -27,12 +27,12 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(!any(is(key<1>), map()));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(key<1>), map()));
 
-    BOOST_HANA_STATIC_ASSERT( any(is(key<1>), map(p<1, 1>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(key<2>), map(p<1, 1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(key<1>), map(p<1, 1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(key<2>), map(p<1, 1>)));
 
-    BOOST_HANA_STATIC_ASSERT( any(is(key<1>), map(p<1, 1>, p<2, 2>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(key<2>), map(p<1, 1>, p<2, 2>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(key<3>), map(p<1, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(key<1>), map(p<1, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(key<2>), map(p<1, 1>, p<2, 2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(key<3>), map(p<1, 1>, p<2, 2>)));
 }
diff --git a/test/map/searchable/find.cpp b/test/map/searchable/find.cpp
index 413950c46..de3eb8797 100644
--- a/test/map/searchable/find.cpp
+++ b/test/map/searchable/find.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -27,13 +27,13 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
     return [=](auto y) { return equal(x, y); };
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(find(is(key<1>), map()) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<1>), map()) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(find(is(key<1>), map(p<1, 1>)) == just(value<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(key<2>), map(p<1, 1>)) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<1>), map(p<1, 1>)) == just(value<1>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<2>), map(p<1, 1>)) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(find(is(key<1>), map(p<1, 1>, p<2, 2>)) == just(value<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(key<2>), map(p<1, 1>, p<2, 2>)) == just(value<2>));
-    BOOST_HANA_STATIC_ASSERT(find(is(key<3>), map(p<1, 1>, p<2, 2>)) == nothing);
-}
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<1>), map(p<1, 1>, p<2, 2>)) == just(value<1>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<2>), map(p<1, 1>, p<2, 2>)) == just(value<2>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(key<3>), map(p<1, 1>, p<2, 2>)) == nothing);
+
+int main() { (void)is; }
diff --git a/test/map/to_list.cpp b/test/map/to_list.cpp
index ff58ea186..813ae8948 100644
--- a/test/map/to_list.cpp
+++ b/test/map/to_list.cpp
@@ -6,11 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -26,9 +26,9 @@ constexpr auto p = detail::minimal::product<>(key<i>, value<j>);
 int main() {
     using L = detail::minimal::List<>;
     constexpr auto list = detail::minimal::list<>;
-    BOOST_HANA_STATIC_ASSERT(to<L>(map()) == list());
-    BOOST_HANA_STATIC_ASSERT(to<L>(map(p<1, 1>)) == list(p<1, 1>));
+    BOOST_HANA_CONSTANT_ASSERT(to<L>(map()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(map(p<1, 1>)) == list(p<1, 1>));
 
-    BOOST_HANA_STATIC_ASSERT(elem(to<L>(map(p<1, 1>, p<2, 2>)), permutations(list(p<1, 1>, p<2, 2>))));
-    BOOST_HANA_STATIC_ASSERT(elem(to<L>(map(p<1, 1>, p<2, 2>, p<3, 3>)), permutations(list(p<1, 1>, p<2, 2>, p<3, 3>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(elem(to<L>(map(p<1, 1>, p<2, 2>)), permutations(list(p<1, 1>, p<2, 2>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(elem(to<L>(map(p<1, 1>, p<2, 2>, p<3, 3>)), permutations(list(p<1, 1>, p<2, 2>, p<3, 3>))));
 }
diff --git a/test/map/values.cpp b/test/map/values.cpp
index 81e2a1bdf..7efeb448b 100644
--- a/test/map/values.cpp
+++ b/test/map/values.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/map.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -23,8 +23,8 @@ template <int i, int j>
 constexpr auto p = detail::minimal::product<>(key<i>, value<j>);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(values(map()) == list());
-    BOOST_HANA_STATIC_ASSERT(values(map(p<1, 1>)) == list(value<1>));
-    BOOST_HANA_STATIC_ASSERT(values(map(p<1, 1>, p<2, 2>)) == list(value<1>, value<2>));
-    BOOST_HANA_STATIC_ASSERT(values(map(p<1, 1>, p<2, 2>, p<3, 3>)) == list(value<1>, value<2>, value<3>));
+    BOOST_HANA_CONSTANT_ASSERT(values(map()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(values(map(p<1, 1>)) == list(value<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(values(map(p<1, 1>, p<2, 2>)) == list(value<1>, value<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(values(map(p<1, 1>, p<2, 2>, p<3, 3>)) == list(value<1>, value<2>, value<3>));
 }
diff --git a/test/maybe/applicative/ap.cpp b/test/maybe/applicative/ap.cpp
index 0634d6614..d5680e034 100644
--- a/test/maybe/applicative/ap.cpp
+++ b/test/maybe/applicative/ap.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -22,8 +22,8 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(ap(nothing, nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(ap(just(f), nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(ap(nothing, just(x<0>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(ap(just(f), just(x<0>)) == just(f(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(ap(nothing, nothing) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(ap(just(f), nothing) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(ap(nothing, just(x<0>)) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(ap(just(f), just(x<0>)) == just(f(x<0>)));
 }
diff --git a/test/maybe/applicative/lift.cpp b/test/maybe/applicative/lift.cpp
index 0a70084e1..d34b420fe 100644
--- a/test/maybe/applicative/lift.cpp
+++ b/test/maybe/applicative/lift.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,5 +15,5 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lift<Maybe>(x<0>) == just(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<Maybe>(x<0>) == just(x<0>));
 }
diff --git a/test/maybe/comparable/equal.cpp b/test/maybe/comparable/equal.cpp
index 4102698e8..818bde31e 100644
--- a/test/maybe/comparable/equal.cpp
+++ b/test/maybe/comparable/equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,9 +15,9 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(nothing, nothing));
-    BOOST_HANA_STATIC_ASSERT(!equal(nothing, just(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(just(x<0>), nothing));
-    BOOST_HANA_STATIC_ASSERT( equal(just(x<0>), just(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(just(x<0>), just(x<1>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(nothing, nothing));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(nothing, just(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(just(x<0>), nothing));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(just(x<0>), just(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(just(x<0>), just(x<1>)));
 }
diff --git a/test/maybe/comparable/laws.cpp b/test/maybe/comparable/laws.cpp
index d372cf9c7..3d0ef7005 100644
--- a/test/maybe/comparable/laws.cpp
+++ b/test/maybe/comparable/laws.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/maybe.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -17,7 +17,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Comparable::laws::check(
         list(
             nothing,
             just(x<0>),
diff --git a/test/maybe/foldable/foldl.cpp b/test/maybe/foldable/foldl.cpp
index 3b569af0e..576ce3799 100644
--- a/test/maybe/foldable/foldl.cpp
+++ b/test/maybe/foldable/foldl.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -23,6 +23,6 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto s, auto x) {
 
 int main() {
     constexpr auto s = x<999>;
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, just(x<0>)) == f(s, x<0>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, nothing) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, just(x<0>)) == f(s, x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, nothing) == s);
 }
diff --git a/test/maybe/foldable/foldr.cpp b/test/maybe/foldable/foldr.cpp
index 29aeec316..1b5ebd948 100644
--- a/test/maybe/foldable/foldr.cpp
+++ b/test/maybe/foldable/foldr.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -23,6 +23,6 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x, auto s) {
 
 int main() {
     constexpr auto s = x<999>;
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, just(x<0>)) == f(x<0>, s));
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, nothing) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, just(x<0>)) == f(x<0>, s));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, nothing) == s);
 }
diff --git a/test/maybe/from_just.cpp b/test/maybe/from_just.cpp
index 010c9c649..b7861316f 100644
--- a/test/maybe/from_just.cpp
+++ b/test/maybe/from_just.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,6 +15,6 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(from_just(just(x<0>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(from_just(just(x<0>)) == x<0>);
     // from_just(nothing);
 }
diff --git a/test/maybe/from_maybe.cpp b/test/maybe/from_maybe.cpp
index 39f4f14a2..8a0db39ed 100644
--- a/test/maybe/from_maybe.cpp
+++ b/test/maybe/from_maybe.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -17,6 +17,6 @@ constexpr auto x = detail::minimal::comparable<>(i);
 struct invalid { };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(from_maybe(x<0>, nothing) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(from_maybe(invalid{}, just(x<1>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(from_maybe(x<0>, nothing) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(from_maybe(invalid{}, just(x<1>)) == x<1>);
 }
diff --git a/test/maybe/functor/fmap.cpp b/test/maybe/functor/fmap.cpp
index 29cfbd3ad..399807e78 100644
--- a/test/maybe/functor/fmap.cpp
+++ b/test/maybe/functor/fmap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -15,7 +15,7 @@ using namespace boost::hana;
 BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) { return x + int_<1>; };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(fmap(f, nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(fmap(f, just(1)) == just(2));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, just(int_<1>)) == just(int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, nothing) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, just(1)) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(fmap(f, just(int_<1>)) == just(int_<2>));
 }
diff --git a/test/maybe/functor/laws.cpp b/test/maybe/functor/laws.cpp
index c65fee770..e222516e5 100644
--- a/test/maybe/functor/laws.cpp
+++ b/test/maybe/functor/laws.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functor/laws.hpp>
 #include <boost/hana/list/instance.hpp>
 
@@ -28,7 +28,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Functor::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Functor::laws::check(
         list(nothing, just(x<0>)),
         list(f),
         list(g)
diff --git a/test/maybe/is_just.cpp b/test/maybe/is_just.cpp
index 2cbdb2919..e03f16891 100644
--- a/test/maybe/is_just.cpp
+++ b/test/maybe/is_just.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct anything { };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( is_just(just(anything{})));
-    BOOST_HANA_STATIC_ASSERT(!is_just(nothing));
+    BOOST_HANA_CONSTANT_ASSERT( is_just(just(anything{})));
+    BOOST_HANA_CONSTANT_ASSERT(!is_just(nothing));
 }
diff --git a/test/maybe/is_nothing.cpp b/test/maybe/is_nothing.cpp
index 78bfcef2b..fceb590bd 100644
--- a/test/maybe/is_nothing.cpp
+++ b/test/maybe/is_nothing.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct anything { };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( is_nothing(nothing));
-    BOOST_HANA_STATIC_ASSERT(!is_nothing(just(anything{})));
+    BOOST_HANA_CONSTANT_ASSERT( is_nothing(nothing));
+    BOOST_HANA_CONSTANT_ASSERT(!is_nothing(just(anything{})));
 }
diff --git a/test/maybe/maybe.cpp b/test/maybe/maybe.cpp
index 8870ed8d7..317e4bc3a 100644
--- a/test/maybe/maybe.cpp
+++ b/test/maybe/maybe.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -24,6 +24,6 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) {
 struct invalid { };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(maybe(x<0>, invalid{}, nothing) == x<0>);
-    BOOST_HANA_STATIC_ASSERT(maybe(invalid{}, f, just(x<0>)) == f(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(maybe(x<0>, invalid{}, nothing) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(maybe(invalid{}, f, just(x<0>)) == f(x<0>));
 }
diff --git a/test/maybe/monad/flatten.cpp b/test/maybe/monad/flatten.cpp
index a650b9870..7d579d163 100644
--- a/test/maybe/monad/flatten.cpp
+++ b/test/maybe/monad/flatten.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,7 +15,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(flatten(nothing) == nothing);
-    BOOST_HANA_STATIC_ASSERT(flatten(just(nothing)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(flatten(just(just(x<0>))) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(nothing) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(flatten(just(nothing)) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(flatten(just(just(x<0>))) == just(x<0>));
 }
diff --git a/test/maybe/monad/laws.cpp b/test/maybe/monad/laws.cpp
index 55a4405b6..7810dd0ad 100644
--- a/test/maybe/monad/laws.cpp
+++ b/test/maybe/monad/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/monad/laws.hpp>
 using namespace boost::hana;
@@ -22,7 +22,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(nothing, int_<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(just(int_<1>), int_<1>, f, g));
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(just(1), int_<1>, f, g));
+    BOOST_HANA_CONSTANT_ASSERT(Monad::laws::check(nothing, int_<1>, f, g));
+    BOOST_HANA_CONSTANT_ASSERT(Monad::laws::check(just(int_<1>), int_<1>, f, g));
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(just(1), int_<1>, f, g));
 }
diff --git a/test/maybe/only_when.cpp b/test/maybe/only_when.cpp
index 7d3d0ac52..21f69e287 100644
--- a/test/maybe/only_when.cpp
+++ b/test/maybe/only_when.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/maybe.hpp>
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -30,7 +30,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto pred = [](auto) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(only_when(pred<true>, f, x<0>) == just(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(only_when(pred<false>, f, x<0>) == nothing);
-    BOOST_HANA_STATIC_ASSERT(only_when(pred<false>, invalid{}, x<0>) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(only_when(pred<true>, f, x<0>) == just(f(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(only_when(pred<false>, f, x<0>) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(only_when(pred<false>, invalid{}, x<0>) == nothing);
 }
diff --git a/test/maybe/searchable/any.cpp b/test/maybe/searchable/any.cpp
index aa37c093c..cae55ada3 100644
--- a/test/maybe/searchable/any.cpp
+++ b/test/maybe/searchable/any.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,7 +20,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( any(is(x<0>), just(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<1>), just(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<0>), nothing));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(x<0>), just(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(x<1>), just(x<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<0>), nothing));
 }
diff --git a/test/maybe/searchable/find.cpp b/test/maybe/searchable/find.cpp
index 1381bba91..c8f8b34b9 100644
--- a/test/maybe/searchable/find.cpp
+++ b/test/maybe/searchable/find.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -19,8 +19,8 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
     return [=](auto y) { return equal(x, y); };
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), just(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), just(x<0>)) == nothing);
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), nothing) == nothing);
-}
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), just(x<0>)) == just(x<0>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), just(x<0>)) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), nothing) == nothing);
+
+int main() { (void)is; }
diff --git a/test/maybe/traversable/traverse.cpp b/test/maybe/traversable/traverse.cpp
index 27896c07f..b110175d2 100644
--- a/test/maybe/traversable/traverse.cpp
+++ b/test/maybe/traversable/traverse.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/maybe.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -30,6 +30,6 @@ constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
     using A = detail::minimal::Applicative<>;
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, just(x<0>)) == applicative(just(g(x<0>))));
-    BOOST_HANA_STATIC_ASSERT(traverse<A>(f, nothing) == applicative(nothing));
+    BOOST_HANA_CONSTEXPR_ASSERT(traverse<A>(f, just(x<0>)) == applicative(just(g(x<0>))));
+    BOOST_HANA_CONSTANT_ASSERT(traverse<A>(f, nothing) == applicative(nothing));
 }
diff --git a/test/monad/bind.cpp b/test/monad/bind.cpp
index 9cfe93aab..091c8627d 100644
--- a/test/monad/bind.cpp
+++ b/test/monad/bind.cpp
@@ -7,10 +7,10 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/monad/bind_mcd.hpp>
 #include <boost/hana/monad/flatten_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/monad.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -24,11 +24,11 @@ void test() {
         return monad(std::make_tuple(x));
     };
 
-    BOOST_HANA_STATIC_ASSERT(bind(monad(comparable(1)), f) == f(comparable(1)));
-    BOOST_HANA_STATIC_ASSERT((monad(comparable(1)) | f) == f(comparable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(bind(monad(comparable(1)), f) == f(comparable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT((monad(comparable(1)) | f) == f(comparable(1)));
 
     // check associativity
-    BOOST_HANA_STATIC_ASSERT((monad(comparable(1)) | f | f) == f(std::make_tuple(comparable(1))));
+    BOOST_HANA_CONSTEXPR_ASSERT((monad(comparable(1)) | f | f) == f(std::make_tuple(comparable(1))));
 }
 
 int main() {
diff --git a/test/monad/laws.cpp b/test/monad/laws.cpp
index 4af1d67ad..6b18aaac1 100644
--- a/test/monad/laws.cpp
+++ b/test/monad/laws.cpp
@@ -8,15 +8,15 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/monad/flatten_mcd.hpp>
 #include <boost/hana/monad/laws.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/monad.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
 template <template <typename ...> class mcd>
 void test() {
     constexpr auto monad = detail::minimal::monad<mcd>;
-    BOOST_HANA_STATIC_ASSERT(Monad::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Monad::laws::check(
         monad(1),
         2,
         [=](auto x) { return monad(x + 1); },
diff --git a/test/monad/then.cpp b/test/monad/then.cpp
index 287bb4557..027554eb1 100644
--- a/test/monad/then.cpp
+++ b/test/monad/then.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/monad/bind_mcd.hpp>
 #include <boost/hana/monad/flatten_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/monad.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -21,7 +21,7 @@ template <template <typename ...> class mcd>
 void test() {
     constexpr auto monad = detail::minimal::monad<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(then(monad(invalid{}), monad(x<1>)) == monad(x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(then(monad(invalid{}), monad(x<1>)) == monad(x<1>));
 }
 
 int main() {
diff --git a/test/orderable/defaults.cpp b/test/orderable/defaults.cpp
index 4eeb08b5b..9a53c6e65 100644
--- a/test/orderable/defaults.cpp
+++ b/test/orderable/defaults.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/datatype.hpp>
 #include <boost/hana/core/is_a.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
@@ -30,13 +30,13 @@ using Integer = datatype_t<integer>;
 using Integer2 = datatype_t<integer2>;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(less(integer{0}, integer{1}));
-    BOOST_HANA_STATIC_ASSERT(!less(integer{0}, integer{0}));
-    BOOST_HANA_STATIC_ASSERT(!less(integer{1}, integer{0}));
-    BOOST_HANA_STATIC_ASSERT(is_a<Orderable, Integer, Integer>);
+    BOOST_HANA_CONSTEXPR_ASSERT(less(integer{0}, integer{1}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!less(integer{0}, integer{0}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!less(integer{1}, integer{0}));
+    BOOST_HANA_CONSTANT_ASSERT(is_a<Orderable, Integer, Integer>);
 
     // No instance is provided when the data type differs from the C++ type.
-    BOOST_HANA_STATIC_ASSERT(!is_a<Orderable, Integer2, Integer2>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Orderable, Integer2, Integer>);
-    BOOST_HANA_STATIC_ASSERT(!is_a<Orderable, Integer, Integer2>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Orderable, Integer2, Integer2>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Orderable, Integer2, Integer>);
+    BOOST_HANA_CONSTANT_ASSERT(!is_a<Orderable, Integer, Integer2>);
 }
diff --git a/test/orderable/greater.cpp b/test/orderable/greater.cpp
index 652e066e8..74febcce2 100644
--- a/test/orderable/greater.cpp
+++ b/test/orderable/greater.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/logical/logical.hpp>
 using namespace boost::hana;
 
@@ -16,15 +16,15 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(greater(orderable(1), orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(not_(greater(orderable(0), orderable(0))));
-    BOOST_HANA_STATIC_ASSERT(not_(greater(orderable(0), orderable(1))));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater(orderable(1), orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(greater(orderable(0), orderable(0))));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(greater(orderable(0), orderable(1))));
 
     // operators
     using operators::operator>;
-    BOOST_HANA_STATIC_ASSERT(orderable(1) > orderable(0));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(0) > orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(0) > orderable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(1) > orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(0) > orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(0) > orderable(1)));
 }
 
 int main() {
diff --git a/test/orderable/greater_equal.cpp b/test/orderable/greater_equal.cpp
index ced547a08..120e7c0e9 100644
--- a/test/orderable/greater_equal.cpp
+++ b/test/orderable/greater_equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/logical/logical.hpp>
 using namespace boost::hana;
 
@@ -16,15 +16,15 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(greater_equal(orderable(1), orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(greater_equal(orderable(0), orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(not_(greater_equal(orderable(0), orderable(1))));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater_equal(orderable(1), orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(greater_equal(orderable(0), orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(greater_equal(orderable(0), orderable(1))));
 
     // operators
     using operators::operator>=;
-    BOOST_HANA_STATIC_ASSERT(orderable(1) >= orderable(0));
-    BOOST_HANA_STATIC_ASSERT(orderable(0) >= orderable(0));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(0) >= orderable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(1) >= orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(0) >= orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(0) >= orderable(1)));
 }
 
 int main() {
diff --git a/test/orderable/laws.cpp b/test/orderable/laws.cpp
index 01fe3470f..47220c632 100644
--- a/test/orderable/laws.cpp
+++ b/test/orderable/laws.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/orderable/laws.hpp>
 using namespace boost::hana;
@@ -16,7 +16,7 @@ using namespace boost::hana;
 template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         Orderable::laws::check(
             list(orderable(1), orderable(2), orderable(3))
         )
diff --git a/test/orderable/less.cpp b/test/orderable/less.cpp
index e0ab69a77..431a20198 100644
--- a/test/orderable/less.cpp
+++ b/test/orderable/less.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/logical/logical.hpp>
 using namespace boost::hana;
 
@@ -16,15 +16,15 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(less(orderable(0), orderable(1)));
-    BOOST_HANA_STATIC_ASSERT(not_(less(orderable(0), orderable(0))));
-    BOOST_HANA_STATIC_ASSERT(not_(less(orderable(1), orderable(0))));
+    BOOST_HANA_CONSTEXPR_ASSERT(less(orderable(0), orderable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(orderable(0), orderable(0))));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less(orderable(1), orderable(0))));
 
     // operators
     using operators::operator<;
-    BOOST_HANA_STATIC_ASSERT(orderable(0) < orderable(1));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(0) < orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(1) < orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(0) < orderable(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(0) < orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(1) < orderable(0)));
 }
 
 int main() {
diff --git a/test/orderable/less_equal.cpp b/test/orderable/less_equal.cpp
index f36757b05..c9da402a5 100644
--- a/test/orderable/less_equal.cpp
+++ b/test/orderable/less_equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/logical/logical.hpp>
 using namespace boost::hana;
 
@@ -16,15 +16,15 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(less_equal(orderable(0), orderable(1)));
-    BOOST_HANA_STATIC_ASSERT(less_equal(orderable(0), orderable(0)));
-    BOOST_HANA_STATIC_ASSERT(not_(less_equal(orderable(1), orderable(0))));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_equal(orderable(0), orderable(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_equal(orderable(0), orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(less_equal(orderable(1), orderable(0))));
 
     // operators
     using operators::operator<=;
-    BOOST_HANA_STATIC_ASSERT(orderable(0) <= orderable(1));
-    BOOST_HANA_STATIC_ASSERT(orderable(0) <= orderable(0));
-    BOOST_HANA_STATIC_ASSERT(not_(orderable(1) <= orderable(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(0) <= orderable(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(orderable(0) <= orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(not_(orderable(1) <= orderable(0)));
 }
 
 int main() {
diff --git a/test/orderable/max.cpp b/test/orderable/max.cpp
index 8a3a6ebb0..13f3e4c9a 100644
--- a/test/orderable/max.cpp
+++ b/test/orderable/max.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,9 +15,9 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(max(orderable(0), orderable(0)) == orderable(0));
-    BOOST_HANA_STATIC_ASSERT(max(orderable(1), orderable(0)) == orderable(1));
-    BOOST_HANA_STATIC_ASSERT(max(orderable(0), orderable(1)) == orderable(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(max(orderable(0), orderable(0)) == orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(max(orderable(1), orderable(0)) == orderable(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(max(orderable(0), orderable(1)) == orderable(1));
 }
 
 int main() {
diff --git a/test/orderable/min.cpp b/test/orderable/min.cpp
index 93c5c5d6b..f19c248de 100644
--- a/test/orderable/min.cpp
+++ b/test/orderable/min.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,9 +15,9 @@ template <typename mcd>
 void test() {
     constexpr auto orderable = detail::minimal::orderable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(min(orderable(0), orderable(0)) == orderable(0));
-    BOOST_HANA_STATIC_ASSERT(min(orderable(1), orderable(0)) == orderable(0));
-    BOOST_HANA_STATIC_ASSERT(min(orderable(0), orderable(1)) == orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(min(orderable(0), orderable(0)) == orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(min(orderable(1), orderable(0)) == orderable(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(min(orderable(0), orderable(1)) == orderable(0));
 }
 
 int main() {
diff --git a/test/orderable/ordering.cpp b/test/orderable/ordering.cpp
index 0f806244d..6020c71b7 100644
--- a/test/orderable/ordering.cpp
+++ b/test/orderable/ordering.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/orderable/less_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/orderable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -24,9 +24,9 @@ void test() {
         return x();
     });
 
-    BOOST_HANA_STATIC_ASSERT(less_(ord_(0), ord_(1)) == less(ord(0), ord(1)));
-    BOOST_HANA_STATIC_ASSERT(less_(ord_(0), ord_(0)) == less(ord(0), ord(0)));
-    BOOST_HANA_STATIC_ASSERT(less_(ord_(1), ord_(0)) == less(ord(1), ord(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_(ord_(0), ord_(1)) == less(ord(0), ord(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_(ord_(0), ord_(0)) == less(ord(0), ord(0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(less_(ord_(1), ord_(0)) == less(ord(1), ord(0)));
 }
 
 int main() {
diff --git a/test/pair/pair.cpp b/test/pair/pair.cpp
index 314c9f3e0..9141aed40 100644
--- a/test/pair/pair.cpp
+++ b/test/pair/pair.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/pair.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,6 +15,6 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(first(pair(x<1>, x<2>)) == x<1>);
-    BOOST_HANA_STATIC_ASSERT(second(pair(x<1>, x<2>)) == x<2>);
+    BOOST_HANA_CONSTEXPR_ASSERT(first(pair(x<1>, x<2>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(pair(x<1>, x<2>)) == x<2>);
 }
diff --git a/test/pair/product/first.cpp b/test/pair/product/first.cpp
index 0bf24daaf..84a1cd5ab 100644
--- a/test/pair/product/first.cpp
+++ b/test/pair/product/first.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/pair.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,5 +15,5 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(first(pair(x<1>, x<2>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(first(pair(x<1>, x<2>)) == x<1>);
 }
diff --git a/test/pair/product/make_product.cpp b/test/pair/product/make_product.cpp
index 5e96c6485..b7141bd43 100644
--- a/test/pair/product/make_product.cpp
+++ b/test/pair/product/make_product.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/pair.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,5 +15,5 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(make_product<Pair>(x<1>, x<2>) == pair(x<1>, x<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(make_product<Pair>(x<1>, x<2>) == pair(x<1>, x<2>));
 }
diff --git a/test/pair/product/second.cpp b/test/pair/product/second.cpp
index cedc5d199..b701eaf12 100644
--- a/test/pair/product/second.cpp
+++ b/test/pair/product/second.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/pair.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,5 +15,5 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(second(pair(x<1>, x<2>)) == x<2>);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(pair(x<1>, x<2>)) == x<2>);
 }
diff --git a/test/product/comparable/equal.cpp b/test/product/comparable/equal.cpp
index f199581ed..152ab2240 100644
--- a/test/product/comparable/equal.cpp
+++ b/test/product/comparable/equal.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/product/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -19,10 +19,10 @@ template <typename mcd>
 void test() {
     constexpr auto prod = detail::minimal::product<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( equal(prod(x<0>, x<1>), prod(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(prod(x<0>, x<1>), prod(x<9>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(prod(x<0>, x<1>), prod(x<0>, x<9>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(prod(x<0>, x<1>), prod(x<9>, x<9>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(prod(x<0>, x<1>), prod(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(prod(x<0>, x<1>), prod(x<9>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(prod(x<0>, x<1>), prod(x<0>, x<9>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(prod(x<0>, x<1>), prod(x<9>, x<9>)));
 }
 
 int main() {
diff --git a/test/product/comparable/laws.cpp b/test/product/comparable/laws.cpp
index a87aa2278..ffdc26b23 100644
--- a/test/product/comparable/laws.cpp
+++ b/test/product/comparable/laws.cpp
@@ -7,9 +7,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/product/mcd.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -21,7 +21,7 @@ template <typename mcd>
 void test() {
     constexpr auto prod = detail::minimal::product<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         Comparable::laws::check(
             list(
                 prod(x<0>, x<1>), prod(x<1>, x<0>),
diff --git a/test/product/first.cpp b/test/product/first.cpp
index 1434bdd27..f3155beb6 100644
--- a/test/product/first.cpp
+++ b/test/product/first.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/product/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,7 +18,7 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     constexpr auto prod = detail::minimal::product<mcd>;
-    BOOST_HANA_STATIC_ASSERT(first(prod(x<0>, x<1>)) == x<0>);
+    BOOST_HANA_CONSTEXPR_ASSERT(first(prod(x<0>, x<1>)) == x<0>);
 }
 
 int main() {
diff --git a/test/product/make_product.cpp b/test/product/make_product.cpp
index 35d536a50..2b46513a7 100644
--- a/test/product/make_product.cpp
+++ b/test/product/make_product.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/product/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,7 +18,7 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     constexpr auto prod = detail::minimal::product<mcd>;
-    BOOST_HANA_STATIC_ASSERT(make_product<mcd>(x<0>, x<1>) == prod(x<0>, x<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(make_product<mcd>(x<0>, x<1>) == prod(x<0>, x<1>));
 }
 
 int main() {
diff --git a/test/product/second.cpp b/test/product/second.cpp
index 2d6806d5e..5f4d1932a 100644
--- a/test/product/second.cpp
+++ b/test/product/second.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/product/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/product.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,7 +18,7 @@ constexpr auto x = detail::minimal::comparable<>(i);
 template <typename mcd>
 void test() {
     constexpr auto prod = detail::minimal::product<mcd>;
-    BOOST_HANA_STATIC_ASSERT(second(prod(x<0>, x<1>)) == x<1>);
+    BOOST_HANA_CONSTEXPR_ASSERT(second(prod(x<0>, x<1>)) == x<1>);
 }
 
 int main() {
diff --git a/test/range/comparable/equal.cpp b/test/range/comparable/equal.cpp
index 37ca32fb9..e4a5f43e8 100644
--- a/test/range/comparable/equal.cpp
+++ b/test/range/comparable/equal.cpp
@@ -6,21 +6,21 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/range.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(range(int_<0>, int_<0>), range(int_<0>, int_<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(range(int_<0>, int_<0>), range(int_<0>, int_<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(range(int_<0>, int_<1>), range(int_<0>, int_<0>)));
-    BOOST_HANA_STATIC_ASSERT( equal(range(int_<0>, int_<1>), range(int_<0>, int_<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(range(int_<0>, int_<2>), range(int_<0>, int_<1>)));
-    BOOST_HANA_STATIC_ASSERT( equal(range(int_<0>, int_<2>), range(int_<0>, int_<2>)));
-    BOOST_HANA_STATIC_ASSERT( equal(range(int_<0>, int_<0>), range(int_<2>, int_<2>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(range(int_<0>, int_<0>), range(int_<0>, int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(range(int_<0>, int_<0>), range(int_<0>, int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(range(int_<0>, int_<1>), range(int_<0>, int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(range(int_<0>, int_<1>), range(int_<0>, int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!equal(range(int_<0>, int_<2>), range(int_<0>, int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(range(int_<0>, int_<2>), range(int_<0>, int_<2>)));
+    BOOST_HANA_CONSTANT_ASSERT( equal(range(int_<0>, int_<0>), range(int_<2>, int_<2>)));
 
-    BOOST_HANA_STATIC_ASSERT(equal(range(int_<2>, int_<4>), range(int_<2>, int_<4>)));
-    BOOST_HANA_STATIC_ASSERT(equal(range(int_<-4>, int_<-3>), range(int_<-4>, int_<-3>)));
-    BOOST_HANA_STATIC_ASSERT(equal(range(int_<-4>, int_<2>), range(int_<-4>, int_<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(equal(range(int_<2>, int_<4>), range(int_<2>, int_<4>)));
+    BOOST_HANA_CONSTANT_ASSERT(equal(range(int_<-4>, int_<-3>), range(int_<-4>, int_<-3>)));
+    BOOST_HANA_CONSTANT_ASSERT(equal(range(int_<-4>, int_<2>), range(int_<-4>, int_<2>)));
 }
diff --git a/test/range/comparable/laws.cpp b/test/range/comparable/laws.cpp
index 2a872e0b0..1479ff7fd 100644
--- a/test/range/comparable/laws.cpp
+++ b/test/range/comparable/laws.cpp
@@ -7,14 +7,14 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/range.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Comparable::laws::check(
         list(
             range(int_<0>, int_<0>),
             range(int_<1>, int_<1>),
diff --git a/test/range/foldable.cpp b/test/range/foldable.cpp
index 172e07955..0bf38c8f3 100644
--- a/test/range/foldable.cpp
+++ b/test/range/foldable.cpp
@@ -6,26 +6,26 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/range.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
 using namespace boost::hana;
 
 
-BOOST_HANA_CONSTEXPR_LAMBDA auto tuple = [](auto ...xs) {
+BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto ...xs) {
     return std::make_tuple(xs...);
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, range(int_<0>, int_<0>)) == tuple());
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, range(int_<0>, int_<1>)) == tuple(int_<0>));
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, range(int_<0>, int_<2>)) == tuple(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(unpack(tuple, range(int_<0>, int_<3>)) == tuple(int_<0>, int_<1>, int_<2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, range(int_<0>, int_<0>)) == f());
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, range(int_<0>, int_<1>)) == f(int_<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, range(int_<0>, int_<2>)) == f(int_<0>, int_<1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(unpack(f, range(int_<0>, int_<3>)) == f(int_<0>, int_<1>, int_<2>));
 
-    BOOST_HANA_STATIC_ASSERT(length(range(int_<0>, int_<0>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(length(range(int_<0>, int_<1>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(length(range(int_<0>, int_<2>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(length(range(int_<4>, int_<4>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(length(range(int_<4>, int_<10>)) == int_<6>);
+    BOOST_HANA_CONSTANT_ASSERT(length(range(int_<0>, int_<0>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(range(int_<0>, int_<1>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(length(range(int_<0>, int_<2>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(length(range(int_<4>, int_<4>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(length(range(int_<4>, int_<10>)) == int_<6>);
 }
diff --git a/test/range/iterable.cpp b/test/range/iterable.cpp
index cf4b8bdf1..89a3b7d78 100644
--- a/test/range/iterable.cpp
+++ b/test/range/iterable.cpp
@@ -6,56 +6,56 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/range.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 void test_drop() {
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, range(int_<0>, int_<0>)) == range(int_<0>, int_<0>));
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, range(int_<0>, int_<1>)) == range(int_<0>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, range(int_<0>, int_<1>)) == range(int_<0>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, range(int_<0>, int_<2>)) == range(int_<0>, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, range(int_<0>, int_<2>)) == range(int_<1>, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, range(int_<0>, int_<2>)) == range(int_<2>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, range(int_<0>, int_<2>)) == range(int_<0>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, range(int_<0>, int_<2>)) == range(int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, range(int_<0>, int_<2>)) == range(int_<2>, int_<2>));
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<0>, range(int_<0>, int_<3>)) == range(int_<0>, int_<3>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<1>, range(int_<0>, int_<3>)) == range(int_<1>, int_<3>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<2>, range(int_<0>, int_<3>)) == range(int_<2>, int_<3>));
-    BOOST_HANA_STATIC_ASSERT(drop(int_<3>, range(int_<0>, int_<3>)) == range(int_<3>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<0>, range(int_<0>, int_<3>)) == range(int_<0>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<1>, range(int_<0>, int_<3>)) == range(int_<1>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<2>, range(int_<0>, int_<3>)) == range(int_<2>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<3>, range(int_<0>, int_<3>)) == range(int_<3>, int_<3>));
 
-    BOOST_HANA_STATIC_ASSERT(drop(int_<10>, range(int_<20>, int_<50>)) == range(int_<30>, int_<50>));
+    BOOST_HANA_CONSTANT_ASSERT(drop(int_<10>, range(int_<20>, int_<50>)) == range(int_<30>, int_<50>));
 }
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(range(int_<0>, int_<0>)));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(range(int_<0>, int_<1>)));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(range(int_<0>, int_<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(is_empty(range(int_<0>, int_<0>)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(range(int_<0>, int_<1>)));
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(range(int_<0>, int_<2>)));
 
-    BOOST_HANA_STATIC_ASSERT(head(range(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(range(int_<0>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(head(range(int_<2>, int_<5>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(head(range(int_<5>, int_<6>)) == int_<5>);
+    BOOST_HANA_CONSTANT_ASSERT(head(range(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(range(int_<0>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(head(range(int_<2>, int_<5>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(head(range(int_<5>, int_<6>)) == int_<5>);
 
-    BOOST_HANA_STATIC_ASSERT(tail(range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
-    BOOST_HANA_STATIC_ASSERT(tail(range(int_<0>, int_<2>)) == range(int_<1>, int_<2>));
-    BOOST_HANA_STATIC_ASSERT(tail(range(int_<0>, int_<3>)) == range(int_<1>, int_<3>));
-    BOOST_HANA_STATIC_ASSERT(tail(range(int_<4>, int_<7>)) == range(int_<5>, int_<7>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(range(int_<0>, int_<1>)) == range(int_<1>, int_<1>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(range(int_<0>, int_<2>)) == range(int_<1>, int_<2>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(range(int_<0>, int_<3>)) == range(int_<1>, int_<3>));
+    BOOST_HANA_CONSTANT_ASSERT(tail(range(int_<4>, int_<7>)) == range(int_<5>, int_<7>));
 
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, range(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<0>, range(int_<0>, int_<2>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<1>, range(int_<0>, int_<2>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(at(int_<46>, range(int_<4>, int_<90>)) == int_<50>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<0>, range(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<0>, range(int_<0>, int_<2>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<1>, range(int_<0>, int_<2>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(at(int_<46>, range(int_<4>, int_<90>)) == int_<50>);
 
-    BOOST_HANA_STATIC_ASSERT(last(range(int_<0>, int_<1>)) == int_<0>);
-    BOOST_HANA_STATIC_ASSERT(last(range(int_<0>, int_<2>)) == int_<1>);
-    BOOST_HANA_STATIC_ASSERT(last(range(int_<0>, int_<3>)) == int_<2>);
-    BOOST_HANA_STATIC_ASSERT(last(range(int_<3>, int_<6>)) == int_<5>);
+    BOOST_HANA_CONSTANT_ASSERT(last(range(int_<0>, int_<1>)) == int_<0>);
+    BOOST_HANA_CONSTANT_ASSERT(last(range(int_<0>, int_<2>)) == int_<1>);
+    BOOST_HANA_CONSTANT_ASSERT(last(range(int_<0>, int_<3>)) == int_<2>);
+    BOOST_HANA_CONSTANT_ASSERT(last(range(int_<3>, int_<6>)) == int_<5>);
 
     test_drop();
 }
diff --git a/test/record/comparable/equal.cpp b/test/record/comparable/equal.cpp
index c6c198e5d..b2e47d602 100644
--- a/test/record/comparable/equal.cpp
+++ b/test/record/comparable/equal.cpp
@@ -5,12 +5,12 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "../udt.hpp"
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(udt{0, '0'}, udt{0, '0'}));
-    BOOST_HANA_STATIC_ASSERT(!equal(udt{0, '0'}, udt{1, '0'}));
-    BOOST_HANA_STATIC_ASSERT(!equal(udt{0, '0'}, udt{0, '1'}));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(udt{0, '0'}, udt{0, '0'}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(udt{0, '0'}, udt{1, '0'}));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(udt{0, '0'}, udt{0, '1'}));
 }
diff --git a/test/record/comparable/laws.cpp b/test/record/comparable/laws.cpp
index d29caf124..eabf224b9 100644
--- a/test/record/comparable/laws.cpp
+++ b/test/record/comparable/laws.cpp
@@ -6,13 +6,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include "../udt.hpp"
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Comparable::laws::check(
         list(udt{0, '0'}, udt{1, '0'}, udt{0, '1'}, udt{1, '1'})
     ));
 }
diff --git a/test/record/foldable/foldl.cpp b/test/record/foldable/foldl.cpp
index fd1144e7c..34ce5238e 100644
--- a/test/record/foldable/foldl.cpp
+++ b/test/record/foldable/foldl.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "../udt.hpp"
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,5 +18,5 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto s, auto x) {
 
 int main() {
     constexpr auto s = 3.3;
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, udt{0, '0'}) == f(f(s, 0), '0'));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, udt{0, '0'}) == f(f(s, 0), '0'));
 }
diff --git a/test/record/foldable/foldr.cpp b/test/record/foldable/foldr.cpp
index 93c31448f..5bc0e9538 100644
--- a/test/record/foldable/foldr.cpp
+++ b/test/record/foldable/foldr.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "../udt.hpp"
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -18,5 +18,5 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x, auto s) {
 
 int main() {
     constexpr auto s = 3.3;
-    BOOST_HANA_STATIC_ASSERT(foldr(f, s, udt{0, '0'}) == f(0, f('0', s)));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldr(f, s, udt{0, '0'}) == f(0, f('0', s)));
 }
diff --git a/test/record/searchable/any.cpp b/test/record/searchable/any.cpp
index 55f91f3ac..bb5b4e711 100644
--- a/test/record/searchable/any.cpp
+++ b/test/record/searchable/any.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "../udt.hpp"
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -14,7 +14,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto k) {
     return [=](auto key) { return equal(k, key); };
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(any(is(member1), udt{0, '0'}));
-    BOOST_HANA_STATIC_ASSERT(any(is(member2), udt{0, '0'}));
-}
+BOOST_HANA_CONSTANT_ASSERT(any(is(member1), udt{0, '0'}));
+BOOST_HANA_CONSTANT_ASSERT(any(is(member2), udt{0, '0'}));
+
+int main() { (void)is; }
diff --git a/test/record/searchable/find.cpp b/test/record/searchable/find.cpp
index df53a0912..97e54f16f 100644
--- a/test/record/searchable/find.cpp
+++ b/test/record/searchable/find.cpp
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "../udt.hpp"
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
 
@@ -16,6 +16,6 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto k) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(find(is(member1), udt{0, '0'}) == just(0));
-    BOOST_HANA_STATIC_ASSERT(find(is(member2), udt{0, '0'}) == just('0'));
+    BOOST_HANA_CONSTEXPR_ASSERT(find(is(member1), udt{0, '0'}) == just(0));
+    BOOST_HANA_CONSTEXPR_ASSERT(find(is(member2), udt{0, '0'}) == just('0'));
 }
diff --git a/test/record/to_map.cpp b/test/record/to_map.cpp
index 983ed9aa6..e347bde10 100644
--- a/test/record/to_map.cpp
+++ b/test/record/to_map.cpp
@@ -5,19 +5,19 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include "udt.hpp"
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/pair.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(to<Map>(udt{0, '0'}) == map(
+    BOOST_HANA_CONSTEXPR_ASSERT(to<Map>(udt{0, '0'}) == map(
         pair(member1, 0),
         pair(member2, '0')
     ));
 
-    BOOST_HANA_STATIC_ASSERT(to<Map>(udt{3, '5'}) == map(
+    BOOST_HANA_CONSTEXPR_ASSERT(to<Map>(udt{3, '5'}) == map(
         pair(member1, 3),
         pair(member2, '5')
     ));
diff --git a/test/sandbox/detail/is_valid.cpp b/test/sandbox/detail/is_valid.cpp
index 319783f3f..d34feb51f 100644
--- a/test/sandbox/detail/is_valid.cpp
+++ b/test/sandbox/detail/is_valid.cpp
@@ -6,18 +6,19 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 constexpr struct { } invalid{};
 
-int main() {
-    auto plus = [](auto x, auto y) -> decltype(x + y) { };
-    BOOST_HANA_STATIC_ASSERT(detail::is_valid(plus)(1, 2));
-    BOOST_HANA_STATIC_ASSERT(!detail::is_valid(plus)(1, invalid));
-    BOOST_HANA_STATIC_ASSERT(!detail::is_valid(plus)(invalid, 1));
+auto plus = [](auto x, auto y) -> decltype(x + y) { };
+BOOST_HANA_CONSTANT_ASSERT(detail::is_valid(plus)(1, 2));
+BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(plus)(1, invalid));
+BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(plus)(invalid, 1));
 
-    BOOST_HANA_STATIC_ASSERT(detail::is_valid([]() -> void {})());
-    BOOST_HANA_STATIC_ASSERT(!detail::is_valid([]() -> void {})(1));
-}
+auto f = []() -> void { };
+BOOST_HANA_CONSTANT_ASSERT(detail::is_valid(f)());
+BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(f)(1));
+
+int main() { (void)plus; (void)f; }
diff --git a/test/sandbox/function.cpp b/test/sandbox/function.cpp
index 00a881cc0..2fb0b82a4 100644
--- a/test/sandbox/function.cpp
+++ b/test/sandbox/function.cpp
@@ -79,7 +79,7 @@ namespace boost { namespace hana {
 // };
 
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 #include <boost/hana/range.hpp>
@@ -100,11 +100,12 @@ int main() {
         [](auto x) { return x - 1_c; }
     );
 
-    BOOST_HANA_STATIC_ASSERT(f == g);
-    BOOST_HANA_STATIC_ASSERT(f != h);
-    BOOST_HANA_STATIC_ASSERT(f(1) == 2);
+    BOOST_HANA_CONSTANT_ASSERT(f == g);
+    BOOST_HANA_CONSTANT_ASSERT(f != h);
+    BOOST_HANA_CONSTEXPR_ASSERT(f(1) == 2);
     try { f(6); throw; } catch (std::domain_error) { }
 
 
-    BOOST_HANA_STATIC_ASSERT(frange(f) == list(4_c, 3_c, 2_c));
+    BOOST_HANA_CONSTANT_ASSERT(frange(f) == list(4_c, 3_c, 2_c));
+    (void)frange;
 }
diff --git a/test/sandbox/infix.cpp b/test/sandbox/infix.cpp
index e51e52f44..45dc17cef 100644
--- a/test/sandbox/infix.cpp
+++ b/test/sandbox/infix.cpp
@@ -169,8 +169,8 @@ namespace boost { namespace hana {
 
 //////////////////////////////////////////////////////////////////////////////
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
 using namespace boost::hana;
 
@@ -179,14 +179,14 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto plus = infix<'/'>(_ + _);
 BOOST_HANA_CONSTEXPR_LAMBDA auto o = infix<'/'>(compose);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(1 /plus/ 2 == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(1 /plus/ 2 == 3);
 
     BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x) { return x % 3; };
     BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto x) { return x * 2; };
     BOOST_HANA_CONSTEXPR_LAMBDA auto h = [](auto x) { return x + 1; };
-    BOOST_HANA_STATIC_ASSERT((f /o/ g /o/ h)(3) == ((3 + 1) * 2) % 3);
+    BOOST_HANA_CONSTEXPR_ASSERT((f /o/ g /o/ h)(3) == ((3 + 1) * 2) % 3);
     // It's better than:
-    BOOST_HANA_STATIC_ASSERT(compose(f, compose(g, h))(3) == ((3 + 1) * 2) % 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, compose(g, h))(3) == ((3 + 1) * 2) % 3);
     // but it's not better than:
-    BOOST_HANA_STATIC_ASSERT(compose(f, g, h)(3) == ((3 + 1) * 2) % 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(compose(f, g, h)(3) == ((3 + 1) * 2) % 3);
 }
diff --git a/test/sandbox/matrix.cpp b/test/sandbox/matrix.cpp
index 1935b13d9..9fc075a26 100644
--- a/test/sandbox/matrix.cpp
+++ b/test/sandbox/matrix.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/comparable/equal_mcd.hpp>
 #include <boost/hana/core/datatype.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/functor/fmap_mcd.hpp>
 #include <boost/hana/integral.hpp>
@@ -175,9 +175,9 @@ void test_sizes() {
         row(1, '2', 3),
         row('4', char_<'5'>, 6)
     );
-    BOOST_HANA_STATIC_ASSERT(m.size() == 6);
-    BOOST_HANA_STATIC_ASSERT(m.ncolumns() == 3);
-    BOOST_HANA_STATIC_ASSERT(m.nrows() == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.size() == 6);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.ncolumns() == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.nrows() == 2);
 }
 
 void test_at() {
@@ -186,29 +186,29 @@ void test_at() {
         row('4', char_<'5'>, 6),
         row(int_<7>, '8', 9.3)
     );
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<0>, int_<0>) == 1);
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<0>, int_<1>) == '2');
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<0>, int_<2>) == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<0>, int_<0>) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<0>, int_<1>) == '2');
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<0>, int_<2>) == 3);
 
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<1>, int_<0>) == '4');
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<1>, int_<1>) == char_<'5'>);
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<1>, int_<2>) == 6);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<1>, int_<0>) == '4');
+    BOOST_HANA_CONSTANT_ASSERT(m.at(int_<1>, int_<1>) == char_<'5'>);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<1>, int_<2>) == 6);
 
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<2>, int_<0>) == int_<7>);
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<2>, int_<1>) == '8');
-    BOOST_HANA_STATIC_ASSERT(m.at(int_<2>, int_<2>) == 9.3);
+    BOOST_HANA_CONSTANT_ASSERT(m.at(int_<2>, int_<0>) == int_<7>);
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<2>, int_<1>) == '8');
+    BOOST_HANA_CONSTEXPR_ASSERT(m.at(int_<2>, int_<2>) == 9.3);
 }
 
 void test_comparable() {
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1, 2)) == matrix(row(1, 2)));
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1, 2)) != matrix(row(1, 5)));
+    BOOST_HANA_CONSTEXPR_ASSERT(matrix(row(1, 2)) == matrix(row(1, 2)));
+    BOOST_HANA_CONSTEXPR_ASSERT(matrix(row(1, 2)) != matrix(row(1, 5)));
 
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1, 2), row(3, 4)) == matrix(row(1, 2), row(3, 4)));
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1, 2), row(3, 4)) != matrix(row(1, 2), row(0, 4)));
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1, 2), row(3, 4)) != matrix(row(0, 2), row(3, 4)));
+    BOOST_HANA_CONSTEXPR_ASSERT(matrix(row(1, 2), row(3, 4)) == matrix(row(1, 2), row(3, 4)));
+    BOOST_HANA_CONSTEXPR_ASSERT(matrix(row(1, 2), row(3, 4)) != matrix(row(1, 2), row(0, 4)));
+    BOOST_HANA_CONSTEXPR_ASSERT(matrix(row(1, 2), row(3, 4)) != matrix(row(0, 2), row(3, 4)));
 
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1), row(2)) != matrix(row(3, 4), row(5, 6)));
-    BOOST_HANA_STATIC_ASSERT(matrix(row(1), row(2)) != matrix(row(3, 4)));
+    BOOST_HANA_CONSTANT_ASSERT(matrix(row(1), row(2)) != matrix(row(3, 4), row(5, 6)));
+    BOOST_HANA_CONSTANT_ASSERT(matrix(row(1), row(2)) != matrix(row(3, 4)));
 }
 
 void test_functor() {
@@ -217,7 +217,7 @@ void test_functor() {
         row(int_<4>, 5, 6),
         row(7, 8, int_<9>)
     );
-    BOOST_HANA_STATIC_ASSERT(fmap(_ + int_<1>, m) ==
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(_ + int_<1>, m) ==
         matrix(
             row(2, int_<3>, 4),
             row(int_<5>, 6, 7),
@@ -228,8 +228,8 @@ void test_functor() {
 
 void test_operators() {
     auto m = matrix(row(1, 2), row(3, 4));
-    BOOST_HANA_STATIC_ASSERT(m + m == matrix(row(2, 4), row(6, 8)));
-    BOOST_HANA_STATIC_ASSERT(m - m == matrix(row(0, 0), row(0, 0)));
+    BOOST_HANA_CONSTEXPR_ASSERT(m + m == matrix(row(2, 4), row(6, 8)));
+    BOOST_HANA_CONSTEXPR_ASSERT(m - m == matrix(row(0, 0), row(0, 0)));
 }
 
 void test_matrix_multiplication() {
@@ -244,7 +244,7 @@ void test_matrix_multiplication() {
         row(5, 6)
     );
 
-    BOOST_HANA_STATIC_ASSERT(A * B == matrix(
+    BOOST_HANA_CONSTEXPR_ASSERT(A * B == matrix(
         row(1*1 + 2*3 + 5*3, 1*2 + 2*4 + 3*6),
         row(4*1 + 3*5 + 5*6, 4*2 + 5*4 + 6*6)
     ));
@@ -252,9 +252,9 @@ void test_matrix_multiplication() {
 
 void test_vector() {
     auto v = vector(1, '2', int_<3>, 4.2f);
-    BOOST_HANA_STATIC_ASSERT(v.size() == 4);
-    BOOST_HANA_STATIC_ASSERT(v.nrows() == 4);
-    BOOST_HANA_STATIC_ASSERT(v.ncolumns() == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(v.size() == 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(v.nrows() == 4);
+    BOOST_HANA_CONSTEXPR_ASSERT(v.ncolumns() == 1);
 }
 
 void test_transpose() {
@@ -262,7 +262,7 @@ void test_transpose() {
         row(1, 2.2, '3'),
         row(4, '5', 6)
     );
-    BOOST_HANA_STATIC_ASSERT(transpose(m) ==
+    BOOST_HANA_CONSTEXPR_ASSERT(transpose(m) ==
         matrix(
             row(1, 4),
             row(2.2, '5'),
@@ -273,20 +273,20 @@ void test_transpose() {
 
 void test_repeat_n() {
     struct T;
-    BOOST_HANA_STATIC_ASSERT(repeat_n(int_<0>, type<T>) == list());
-    BOOST_HANA_STATIC_ASSERT(repeat_n(int_<1>, type<T>) == list(type<T>));
-    BOOST_HANA_STATIC_ASSERT(repeat_n(int_<2>, type<T>) == list(type<T>, type<T>));
-    BOOST_HANA_STATIC_ASSERT(repeat_n(int_<3>, type<T>) == list(type<T>, type<T>, type<T>));
-    BOOST_HANA_STATIC_ASSERT(repeat_n(int_<4>, type<T>) == list(type<T>, type<T>, type<T>, type<T>));
+    BOOST_HANA_CONSTANT_ASSERT(repeat_n(int_<0>, type<T>) == list());
+    BOOST_HANA_CONSTANT_ASSERT(repeat_n(int_<1>, type<T>) == list(type<T>));
+    BOOST_HANA_CONSTANT_ASSERT(repeat_n(int_<2>, type<T>) == list(type<T>, type<T>));
+    BOOST_HANA_CONSTANT_ASSERT(repeat_n(int_<3>, type<T>) == list(type<T>, type<T>, type<T>));
+    BOOST_HANA_CONSTANT_ASSERT(repeat_n(int_<4>, type<T>) == list(type<T>, type<T>, type<T>, type<T>));
 }
 
 void test_determinant() {
-    BOOST_HANA_STATIC_ASSERT(det(matrix(row(1))) == 1);
-    BOOST_HANA_STATIC_ASSERT(det(matrix(row(2))) == 2);
+    BOOST_HANA_CONSTEXPR_ASSERT(det(matrix(row(1))) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(det(matrix(row(2))) == 2);
 
-    BOOST_HANA_STATIC_ASSERT(det(matrix(row(1, 2), row(3, 4))) == -2);
+    BOOST_HANA_CONSTEXPR_ASSERT(det(matrix(row(1, 2), row(3, 4))) == -2);
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         det(matrix(
             row(1, 5, 6),
             row(3, 2, 4),
@@ -295,7 +295,7 @@ void test_determinant() {
         == 51
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         det(matrix(
             row(1, 5, 6, -3),
             row(3, 2, 4, -5),
@@ -304,7 +304,7 @@ void test_determinant() {
         )) == 214
     );
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         det(matrix(
             row(1,  5,  6, -3, 92),
             row(3,  2,  4, -5, 13),
@@ -316,22 +316,22 @@ void test_determinant() {
 }
 
 void test_remove_at() {
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<0>, list(1)) == list());
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<0>, list(1, '2')) == list('2'));
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<0>, list(1, '2', 3.3)) == list('2', 3.3));
+    BOOST_HANA_CONSTANT_ASSERT(remove_at(int_<0>, list(1)) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(remove_at(int_<0>, list(1, '2')) == list('2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(remove_at(int_<0>, list(1, '2', 3.3)) == list('2', 3.3));
 
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<1>, list(1, '2')) == list(1));
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<1>, list(1, '2', 3.3)) == list(1, 3.3));
+    BOOST_HANA_CONSTEXPR_ASSERT(remove_at(int_<1>, list(1, '2')) == list(1));
+    BOOST_HANA_CONSTEXPR_ASSERT(remove_at(int_<1>, list(1, '2', 3.3)) == list(1, 3.3));
 
-    BOOST_HANA_STATIC_ASSERT(remove_at(int_<2>, list(1, '2', 3.3)) == list(1, '2'));
+    BOOST_HANA_CONSTEXPR_ASSERT(remove_at(int_<2>, list(1, '2', 3.3)) == list(1, '2'));
 }
 
 void test_exponent() {
-    BOOST_HANA_STATIC_ASSERT(exponent(3, 0) == 1);
-    BOOST_HANA_STATIC_ASSERT(exponent(3, 1) == 3);
-    BOOST_HANA_STATIC_ASSERT(exponent(3, 2) == 3 * 3);
-    BOOST_HANA_STATIC_ASSERT(exponent(3, 3) == 3 * 3 * 3);
-    BOOST_HANA_STATIC_ASSERT(exponent(3, 4) == 3 * 3 * 3 * 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(exponent(3, 0) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(exponent(3, 1) == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(exponent(3, 2) == 3 * 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(exponent(3, 3) == 3 * 3 * 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(exponent(3, 4) == 3 * 3 * 3 * 3);
 }
 
 int main() {
diff --git a/test/sandbox/operator.cpp b/test/sandbox/operator.cpp
index 1f156ce07..35905b542 100644
--- a/test/sandbox/operator.cpp
+++ b/test/sandbox/operator.cpp
@@ -65,11 +65,15 @@ namespace boost { namespace hana {
 
 //////////////////////////////////////////////////////////////////////////////
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
+int unused_impl(...) { return 1; }
+template <char ...op> int unused = unused_impl(operator_<op>...);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(operator_<'+'>(1, 2) == 3);
-    BOOST_HANA_STATIC_ASSERT(operator_<'!'>(true) == false);
+    BOOST_HANA_CONSTEXPR_ASSERT(operator_<'+'>(1, 2) == 3);
+    BOOST_HANA_CONSTEXPR_ASSERT(operator_<'!'>(true) == false);
+
+    (void)unused<'+', '-', '*', '/', '%', '~', '&', '|', '^', '<', '>'>;
 }
diff --git a/test/sandbox/repeat.cpp b/test/sandbox/repeat.cpp
index 16fc0b458..65e776370 100644
--- a/test/sandbox/repeat.cpp
+++ b/test/sandbox/repeat.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/iterable/mcd.hpp>
@@ -68,9 +68,9 @@ namespace boost { namespace hana {
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(!is_empty(repeat(1)));
-    BOOST_HANA_STATIC_ASSERT(head(repeat(1)) == 1);
-    BOOST_HANA_STATIC_ASSERT(at(int_<10>, repeat(1)) == 1);
+    BOOST_HANA_CONSTANT_ASSERT(!is_empty(repeat(1)));
+    BOOST_HANA_CONSTEXPR_ASSERT(head(repeat(1)) == 1);
+    BOOST_HANA_CONSTEXPR_ASSERT(at(int_<10>, repeat(1)) == 1);
 
-    BOOST_HANA_STATIC_ASSERT(take(int_<2>, repeat('x')) == list('x', 'x'));
+    BOOST_HANA_CONSTEXPR_ASSERT(take(int_<2>, repeat('x')) == list('x', 'x'));
 }
diff --git a/test/sandbox/searchable_set/applicative/ap.cpp b/test/sandbox/searchable_set/applicative/ap.cpp
index 36be1f999..c9079190d 100644
--- a/test/sandbox/searchable_set/applicative/ap.cpp
+++ b/test/sandbox/searchable_set/applicative/ap.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 
 #include <tuple>
@@ -26,10 +26,13 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto g = [](auto x) {
     return x * int_<20>;
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(ap(singleton(f), singleton(x<0>)) == singleton(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(singleton(f), doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
+BOOST_HANA_CONSTANT_ASSERT(ap(singleton(f), singleton(x<0>)) == singleton(f(x<0>)));
+BOOST_HANA_CONSTANT_ASSERT(ap(singleton(f), doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT(ap(doubleton(f, g), singleton(x<0>)) == doubleton(f(x<0>), g(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(ap(doubleton(f, g), doubleton(x<0>, x<1>)) == union_(doubleton(f(x<0>), f(x<1>)), doubleton(g(x<0>), g(x<1>))));
+BOOST_HANA_CONSTANT_ASSERT(ap(doubleton(f, g), singleton(x<0>)) == doubleton(f(x<0>), g(x<0>)));
+BOOST_HANA_CONSTANT_ASSERT(ap(doubleton(f, g), doubleton(x<0>, x<1>)) == union_(doubleton(f(x<0>), f(x<1>)), doubleton(g(x<0>), g(x<1>))));
+
+int main() {
+    (void)f;
+    (void)g;
 }
diff --git a/test/sandbox/searchable_set/applicative/lift.cpp b/test/sandbox/searchable_set/applicative/lift.cpp
index 8d38187ab..c6eee07e7 100644
--- a/test/sandbox/searchable_set/applicative/lift.cpp
+++ b/test/sandbox/searchable_set/applicative/lift.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,5 +15,5 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(lift<SearchableSet>(x<0>) == singleton(x<0>));
+    BOOST_HANA_CONSTEXPR_ASSERT(lift<SearchableSet>(x<0>) == singleton(x<0>));
 }
diff --git a/test/sandbox/searchable_set/comparable/equal.cpp b/test/sandbox/searchable_set/comparable/equal.cpp
index 40321f976..2d82185cf 100644
--- a/test/sandbox/searchable_set/comparable/equal.cpp
+++ b/test/sandbox/searchable_set/comparable/equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,15 +15,15 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(singleton(x<0>), singleton(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(singleton(x<0>), singleton(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(singleton(x<0>), singleton(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(singleton(x<0>), singleton(x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT( equal(singleton(x<0>), doubleton(x<0>, x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(singleton(x<0>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(singleton(x<0>), doubleton(x<1>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(singleton(x<0>), doubleton(x<0>, x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(singleton(x<0>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(singleton(x<0>), doubleton(x<1>, x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT( equal(doubleton(x<0>, x<1>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT( equal(doubleton(x<0>, x<1>), doubleton(x<1>, x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(doubleton(x<0>, x<1>), doubleton(x<0>, x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!equal(doubleton(x<0>, x<1>), doubleton(x<3>, x<4>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(doubleton(x<0>, x<1>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( equal(doubleton(x<0>, x<1>), doubleton(x<1>, x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(doubleton(x<0>, x<1>), doubleton(x<0>, x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!equal(doubleton(x<0>, x<1>), doubleton(x<3>, x<4>)));
 }
diff --git a/test/sandbox/searchable_set/comparable/laws.cpp b/test/sandbox/searchable_set/comparable/laws.cpp
index e19d92072..7bd4a5221 100644
--- a/test/sandbox/searchable_set/comparable/laws.cpp
+++ b/test/sandbox/searchable_set/comparable/laws.cpp
@@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/sandbox/searchable_set.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -17,7 +17,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTEXPR_ASSERT(Comparable::laws::check(
         list(
             singleton(x<0>),
             singleton(x<1>),
diff --git a/test/sandbox/searchable_set/contains.cpp b/test/sandbox/searchable_set/contains.cpp
index 1acd508cd..fc239c414 100644
--- a/test/sandbox/searchable_set/contains.cpp
+++ b/test/sandbox/searchable_set/contains.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,10 +15,10 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( contains(x<0>, singleton(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!contains(x<1>, singleton(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( contains(x<0>, singleton(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!contains(x<1>, singleton(x<0>)));
 
-    BOOST_HANA_STATIC_ASSERT( contains(x<0>, doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT( contains(x<1>, doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!contains(x<2>, doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( contains(x<0>, doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( contains(x<1>, doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!contains(x<2>, doubleton(x<0>, x<1>)));
 }
diff --git a/test/sandbox/searchable_set/forall.cpp b/test/sandbox/searchable_set/forall.cpp
index d053fd3a5..a0df68c8c 100644
--- a/test/sandbox/searchable_set/forall.cpp
+++ b/test/sandbox/searchable_set/forall.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,9 +20,9 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto isnt = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(!forall(singleton(x<0>), isnt(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( forall(singleton(x<0>), isnt(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!forall(doubleton(x<0>, x<1>), isnt(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!forall(doubleton(x<0>, x<1>), isnt(x<1>)));
-    BOOST_HANA_STATIC_ASSERT( forall(doubleton(x<0>, x<1>), isnt(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!forall(singleton(x<0>), isnt(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( forall(singleton(x<0>), isnt(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!forall(doubleton(x<0>, x<1>), isnt(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!forall(doubleton(x<0>, x<1>), isnt(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( forall(doubleton(x<0>, x<1>), isnt(x<2>)));
 }
diff --git a/test/sandbox/searchable_set/forsome.cpp b/test/sandbox/searchable_set/forsome.cpp
index 15051b727..cc927dc9f 100644
--- a/test/sandbox/searchable_set/forsome.cpp
+++ b/test/sandbox/searchable_set/forsome.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,9 +20,9 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( forsome(singleton(x<0>), is(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!forsome(singleton(x<0>), is(x<1>)));
-    BOOST_HANA_STATIC_ASSERT( forsome(doubleton(x<0>, x<1>), is(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( forsome(doubleton(x<0>, x<1>), is(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!forsome(doubleton(x<0>, x<1>), is(x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( forsome(singleton(x<0>), is(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!forsome(singleton(x<0>), is(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( forsome(doubleton(x<0>, x<1>), is(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( forsome(doubleton(x<0>, x<1>), is(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!forsome(doubleton(x<0>, x<1>), is(x<2>)));
 }
diff --git a/test/sandbox/searchable_set/functor/fmap.cpp b/test/sandbox/searchable_set/functor/fmap.cpp
index e03cb2de5..dc10da70f 100644
--- a/test/sandbox/searchable_set/functor/fmap.cpp
+++ b/test/sandbox/searchable_set/functor/fmap.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -22,7 +22,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(fmap(f, singleton(x<0>)) == singleton(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(fmap(f, doubleton(x<0>, x<0>)) == singleton(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, singleton(x<0>)) == singleton(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(fmap(f, doubleton(x<0>, x<0>)) == singleton(f(x<0>)));
 }
diff --git a/test/sandbox/searchable_set/image.cpp b/test/sandbox/searchable_set/image.cpp
index 9bac4b41e..2329314c0 100644
--- a/test/sandbox/searchable_set/image.cpp
+++ b/test/sandbox/searchable_set/image.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -22,7 +22,7 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(image(f, singleton(x<0>)) == singleton(f(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(image(f, doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(image(f, doubleton(x<0>, x<0>)) == singleton(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(image(f, singleton(x<0>)) == singleton(f(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(image(f, doubleton(x<0>, x<1>)) == doubleton(f(x<0>), f(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(image(f, doubleton(x<0>, x<0>)) == singleton(f(x<0>)));
 }
diff --git a/test/sandbox/searchable_set/monad/flatten.cpp b/test/sandbox/searchable_set/monad/flatten.cpp
index 3edccd376..cf8408154 100644
--- a/test/sandbox/searchable_set/monad/flatten.cpp
+++ b/test/sandbox/searchable_set/monad/flatten.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -16,11 +16,11 @@ template <int i>
 constexpr auto x = int_<i>;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(flatten(singleton(singleton(x<0>))) == singleton(x<0>));
-    BOOST_HANA_STATIC_ASSERT(flatten(singleton(doubleton(x<0>, x<1>))) == doubleton(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(singleton(singleton(x<0>))) == singleton(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(singleton(doubleton(x<0>, x<1>))) == doubleton(x<0>, x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(flatten(doubleton(singleton(x<0>), singleton(x<1>))) == doubleton(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(flatten(doubleton(doubleton(x<0>, x<1>), singleton(x<2>))) == union_(doubleton(x<0>, x<1>), singleton(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(flatten(doubleton(singleton(x<0>), doubleton(x<1>, x<2>))) == union_(doubleton(x<0>, x<1>), singleton(x<2>)));
-    BOOST_HANA_STATIC_ASSERT(flatten(doubleton(doubleton(x<0>, x<1>), doubleton(x<2>, x<3>))) == union_(doubleton(x<0>, x<1>), doubleton(x<2>, x<3>)));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(doubleton(singleton(x<0>), singleton(x<1>))) == doubleton(x<0>, x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(doubleton(doubleton(x<0>, x<1>), singleton(x<2>))) == union_(doubleton(x<0>, x<1>), singleton(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(doubleton(singleton(x<0>), doubleton(x<1>, x<2>))) == union_(doubleton(x<0>, x<1>), singleton(x<2>)));
+    BOOST_HANA_CONSTANT_ASSERT(flatten(doubleton(doubleton(x<0>, x<1>), doubleton(x<2>, x<3>))) == union_(doubleton(x<0>, x<1>), doubleton(x<2>, x<3>)));
 }
diff --git a/test/sandbox/searchable_set/search.cpp b/test/sandbox/searchable_set/search.cpp
index 2cbcff94e..982b4b012 100644
--- a/test/sandbox/searchable_set/search.cpp
+++ b/test/sandbox/searchable_set/search.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -20,11 +20,11 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
     return [=](auto y) { return equal(x, y); };
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(search(singleton(x<0>), is(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(search(singleton(x<1>), is(x<0>)) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(search(singleton(x<0>), is(x<0>)) == just(x<0>));
+BOOST_HANA_CONSTANT_ASSERT(search(singleton(x<1>), is(x<0>)) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(search(doubleton(x<0>, x<1>), is(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(search(doubleton(x<0>, x<1>), is(x<1>)) == just(x<1>));
-    BOOST_HANA_STATIC_ASSERT(search(doubleton(x<0>, x<1>), is(x<2>)) == nothing);
-}
+BOOST_HANA_CONSTANT_ASSERT(search(doubleton(x<0>, x<1>), is(x<0>)) == just(x<0>));
+BOOST_HANA_CONSTANT_ASSERT(search(doubleton(x<0>, x<1>), is(x<1>)) == just(x<1>));
+BOOST_HANA_CONSTANT_ASSERT(search(doubleton(x<0>, x<1>), is(x<2>)) == nothing);
+
+int main() { (void)is; }
diff --git a/test/sandbox/searchable_set/subset.cpp b/test/sandbox/searchable_set/subset.cpp
index 506adefea..ed9286c79 100644
--- a/test/sandbox/searchable_set/subset.cpp
+++ b/test/sandbox/searchable_set/subset.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -15,14 +15,14 @@ template <int i>
 constexpr auto x = detail::minimal::comparable<>(i);
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT( subset(singleton(x<0>), singleton(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!subset(singleton(x<1>), singleton(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( subset(singleton(x<0>), singleton(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!subset(singleton(x<1>), singleton(x<0>)));
 
-    BOOST_HANA_STATIC_ASSERT( subset(singleton(x<0>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT( subset(singleton(x<1>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!subset(singleton(x<2>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( subset(singleton(x<0>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( subset(singleton(x<1>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!subset(singleton(x<2>), doubleton(x<0>, x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT( subset(doubleton(x<0>, x<1>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!subset(doubleton(x<0>, x<2>), doubleton(x<0>, x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!subset(doubleton(x<2>, x<3>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( subset(doubleton(x<0>, x<1>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!subset(doubleton(x<0>, x<2>), doubleton(x<0>, x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!subset(doubleton(x<2>, x<3>), doubleton(x<0>, x<1>)));
 }
diff --git a/test/sandbox/searchable_set/union.cpp b/test/sandbox/searchable_set/union.cpp
index 05bb271e4..8285007bb 100644
--- a/test/sandbox/searchable_set/union.cpp
+++ b/test/sandbox/searchable_set/union.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/sandbox/searchable_set.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -15,8 +15,8 @@ using namespace boost::hana;
 template <int i>
 constexpr auto x = int_<i>;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(union_(singleton(x<0>), singleton(x<0>)) == singleton(x<0>));
-    BOOST_HANA_STATIC_ASSERT(union_(singleton(x<0>), singleton(x<1>)) == doubleton(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(union_(singleton(x<0>), doubleton(x<0>, x<1>)) == doubleton(x<0>, x<1>));
-}
+BOOST_HANA_CONSTANT_ASSERT(union_(singleton(x<0>), singleton(x<0>)) == singleton(x<0>));
+BOOST_HANA_CONSTANT_ASSERT(union_(singleton(x<0>), singleton(x<1>)) == doubleton(x<0>, x<1>));
+BOOST_HANA_CONSTANT_ASSERT(union_(singleton(x<0>), doubleton(x<0>, x<1>)) == doubleton(x<0>, x<1>));
+
+int main() { }
diff --git a/test/sandbox/sfinae.cpp b/test/sandbox/sfinae.cpp
index ef3de3bbe..4f529c93b 100644
--- a/test/sandbox/sfinae.cpp
+++ b/test/sandbox/sfinae.cpp
@@ -4,8 +4,8 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/maybe.hpp>
 
 #include <string>
@@ -40,8 +40,8 @@ int main() {
         return x + 1;
     });
 
-    BOOST_HANA_STATIC_ASSERT(f(1) == just(2));
-    BOOST_HANA_STATIC_ASSERT(f(std::string{"abc"}) == nothing);
+    BOOST_HANA_CONSTEXPR_ASSERT(f(1) == just(2));
+    BOOST_HANA_CONSTANT_ASSERT(f(std::string{"abc"}) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(bind(just(1), f) == just(2));
+    BOOST_HANA_CONSTEXPR_ASSERT(bind(just(1), f) == just(2));
 }
diff --git a/test/searchable/all.cpp b/test/searchable/all.cpp
index d6cd15a50..2a101c9f6 100644
--- a/test/searchable/all.cpp
+++ b/test/searchable/all.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -23,8 +23,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( all(is(x<0>), searchable(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!all(is(x<1>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( all(is(x<0>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!all(is(x<1>), searchable(x<0>)));
 };
 
 int main() {
diff --git a/test/searchable/all_of.cpp b/test/searchable/all_of.cpp
index 318a2f9e9..51fc1fd49 100644
--- a/test/searchable/all_of.cpp
+++ b/test/searchable/all_of.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,8 +18,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( all_of(searchable(x<true>)));
-    BOOST_HANA_STATIC_ASSERT(!all_of(searchable(x<false>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( all_of(searchable(x<true>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!all_of(searchable(x<false>)));
 };
 
 int main() {
diff --git a/test/searchable/any.cpp b/test/searchable/any.cpp
index 3687b39d2..e444446b6 100644
--- a/test/searchable/any.cpp
+++ b/test/searchable/any.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -23,8 +23,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( any(is(x<0>), searchable(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<1>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(x<0>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(x<1>), searchable(x<0>)));
 };
 
 int main() {
diff --git a/test/searchable/any_of.cpp b/test/searchable/any_of.cpp
index 70c1e45d6..78397ff18 100644
--- a/test/searchable/any_of.cpp
+++ b/test/searchable/any_of.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,8 +18,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( any_of(searchable(x<true>)));
-    BOOST_HANA_STATIC_ASSERT(!any_of(searchable(x<false>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any_of(searchable(x<true>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any_of(searchable(x<false>)));
 };
 
 int main() {
diff --git a/test/searchable/elem.cpp b/test/searchable/elem.cpp
index d58e3b276..7d90fb15f 100644
--- a/test/searchable/elem.cpp
+++ b/test/searchable/elem.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -19,8 +19,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT( elem(x<0>, searchable(x<0>)));
-    BOOST_HANA_STATIC_ASSERT(!elem(x<1>, searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( elem(x<0>, searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!elem(x<1>, searchable(x<0>)));
 };
 
 int main() {
diff --git a/test/searchable/find.cpp b/test/searchable/find.cpp
index 1d1ab5f53..cc0912bd6 100644
--- a/test/searchable/find.cpp
+++ b/test/searchable/find.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -24,10 +24,11 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<0>), searchable(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), searchable(x<0>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<0>), searchable(x<0>)) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), searchable(x<0>)) == nothing);
 };
 
 int main() {
     test<Searchable::mcd>();
+    (void)is;
 }
diff --git a/test/searchable/lookup.cpp b/test/searchable/lookup.cpp
index cbb658f01..5e6c19ef2 100644
--- a/test/searchable/lookup.cpp
+++ b/test/searchable/lookup.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -20,8 +20,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(lookup(x<0>, searchable(x<0>)) == just(x<0>));
-    BOOST_HANA_STATIC_ASSERT(lookup(x<1>, searchable(x<0>)) == nothing);
+    BOOST_HANA_CONSTANT_ASSERT(lookup(x<0>, searchable(x<0>)) == just(x<0>));
+    BOOST_HANA_CONSTANT_ASSERT(lookup(x<1>, searchable(x<0>)) == nothing);
 };
 
 int main() {
diff --git a/test/searchable/none.cpp b/test/searchable/none.cpp
index f88d77300..8b6fe15db 100644
--- a/test/searchable/none.cpp
+++ b/test/searchable/none.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -23,8 +23,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(!none(is(x<0>), searchable(x<0>)));
-    BOOST_HANA_STATIC_ASSERT( none(is(x<1>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!none(is(x<0>), searchable(x<0>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( none(is(x<1>), searchable(x<0>)));
 };
 
 int main() {
diff --git a/test/searchable/none_of.cpp b/test/searchable/none_of.cpp
index 359484856..0541b21f3 100644
--- a/test/searchable/none_of.cpp
+++ b/test/searchable/none_of.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/searchable/mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/searchable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,8 +18,8 @@ template <typename mcd>
 void test() {
     constexpr auto searchable = detail::minimal::searchable<mcd>;
 
-    BOOST_HANA_STATIC_ASSERT(!none_of(searchable(x<true>)));
-    BOOST_HANA_STATIC_ASSERT( none_of(searchable(x<false>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!none_of(searchable(x<true>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( none_of(searchable(x<false>)));
 };
 
 int main() {
diff --git a/test/set/comparable/equal.cpp b/test/set/comparable/equal.cpp
index b73490f6f..a78539848 100644
--- a/test/set/comparable/equal.cpp
+++ b/test/set/comparable/equal.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -24,9 +24,9 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto check = [](auto ...xs) {
     );
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(check());
-    BOOST_HANA_STATIC_ASSERT(check(x<0>));
-    BOOST_HANA_STATIC_ASSERT(check(x<0>, x<1>));
-    BOOST_HANA_STATIC_ASSERT(check(x<0>, x<1>, x<2>));
-}
+BOOST_HANA_CONSTANT_ASSERT(check());
+BOOST_HANA_CONSTANT_ASSERT(check(x<0>));
+BOOST_HANA_CONSTANT_ASSERT(check(x<0>, x<1>));
+BOOST_HANA_CONSTANT_ASSERT(check(x<0>, x<1>, x<2>));
+
+int main() { (void)check; }
diff --git a/test/set/comparable/laws.cpp b/test/set/comparable/laws.cpp
index 9bc64b3ce..82c67f76d 100644
--- a/test/set/comparable/laws.cpp
+++ b/test/set/comparable/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/set.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
@@ -17,7 +17,7 @@ template <int i>
 constexpr auto x = int_<i>;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
+    BOOST_HANA_CONSTANT_ASSERT(Comparable::laws::check(
         list(
             set(),
             set(x<0>),
diff --git a/test/set/from_list.cpp b/test/set/from_list.cpp
index f9dc9fb6a..bc54dc49f 100644
--- a/test/set/from_list.cpp
+++ b/test/set/from_list.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
@@ -18,8 +18,8 @@ constexpr auto x = int_<i>;
 int main() {
     constexpr auto list = detail::minimal::list<>;
 
-    BOOST_HANA_STATIC_ASSERT(to<Set>(list()) == set());
-    BOOST_HANA_STATIC_ASSERT(to<Set>(list(x<1>)) == set(x<1>));
-    BOOST_HANA_STATIC_ASSERT(to<Set>(list(x<1>, x<2>)) == set(x<1>, x<2>));
-    BOOST_HANA_STATIC_ASSERT(to<Set>(list(x<1>, x<2>, x<3>)) == set(x<1>, x<2>, x<3>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Set>(list()) == set());
+    BOOST_HANA_CONSTANT_ASSERT(to<Set>(list(x<1>)) == set(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Set>(list(x<1>, x<2>)) == set(x<1>, x<2>));
+    BOOST_HANA_CONSTANT_ASSERT(to<Set>(list(x<1>, x<2>, x<3>)) == set(x<1>, x<2>, x<3>));
 }
diff --git a/test/set/searchable/any.cpp b/test/set/searchable/any.cpp
index 03d850cc9..ac13a7454 100644
--- a/test/set/searchable/any.cpp
+++ b/test/set/searchable/any.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -20,12 +20,12 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
 };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<1>), set()));
+    BOOST_HANA_CONSTANT_ASSERT(!any(is(x<1>), set()));
 
-    BOOST_HANA_STATIC_ASSERT( any(is(x<1>), set(x<1>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<2>), set(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(x<1>), set(x<1>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(x<2>), set(x<1>)));
 
-    BOOST_HANA_STATIC_ASSERT( any(is(x<1>), set(x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT( any(is(x<2>), set(x<1>, x<2>)));
-    BOOST_HANA_STATIC_ASSERT(!any(is(x<3>), set(x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(x<1>), set(x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT( any(is(x<2>), set(x<1>, x<2>)));
+    BOOST_HANA_CONSTEXPR_ASSERT(!any(is(x<3>), set(x<1>, x<2>)));
 }
diff --git a/test/set/searchable/find.cpp b/test/set/searchable/find.cpp
index 1149a0b90..815391e64 100644
--- a/test/set/searchable/find.cpp
+++ b/test/set/searchable/find.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/maybe.hpp>
 using namespace boost::hana;
@@ -20,13 +20,13 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto is = [](auto x) {
     return [=](auto y) { return equal(x, y); };
 };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), set()) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), set()) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), set(x<1>)) == just(x<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<2>), set(x<1>)) == nothing);
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), set(x<1>)) == just(x<1>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<2>), set(x<1>)) == nothing);
 
-    BOOST_HANA_STATIC_ASSERT(find(is(x<1>), set(x<1>, x<2>)) == just(x<1>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<2>), set(x<1>, x<2>)) == just(x<2>));
-    BOOST_HANA_STATIC_ASSERT(find(is(x<3>), set(x<1>, x<2>)) == nothing);
-}
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<1>), set(x<1>, x<2>)) == just(x<1>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<2>), set(x<1>, x<2>)) == just(x<2>));
+BOOST_HANA_CONSTANT_ASSERT(find(is(x<3>), set(x<1>, x<2>)) == nothing);
+
+int main() { (void)is; }
diff --git a/test/set/to_list.cpp b/test/set/to_list.cpp
index c36b42546..0c67facfd 100644
--- a/test/set/to_list.cpp
+++ b/test/set/to_list.cpp
@@ -6,9 +6,9 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/set.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/list.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -18,9 +18,9 @@ constexpr auto x = detail::minimal::comparable<>(i);
 int main() {
     using L = detail::minimal::List<>;
     constexpr auto list = detail::minimal::list<>;
-    BOOST_HANA_STATIC_ASSERT(to<L>(set()) == list());
-    BOOST_HANA_STATIC_ASSERT(to<L>(set(x<1>)) == list(x<1>));
+    BOOST_HANA_CONSTANT_ASSERT(to<L>(set()) == list());
+    BOOST_HANA_CONSTEXPR_ASSERT(to<L>(set(x<1>)) == list(x<1>));
 
-    BOOST_HANA_STATIC_ASSERT(elem(to<L>(set(x<1>, x<2>)), permutations(list(x<1>, x<2>))));
-    BOOST_HANA_STATIC_ASSERT(elem(to<L>(set(x<1>, x<2>, x<3>)), permutations(list(x<1>, x<2>, x<3>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(elem(to<L>(set(x<1>, x<2>)), permutations(list(x<1>, x<2>))));
+    BOOST_HANA_CONSTEXPR_ASSERT(elem(to<L>(set(x<1>, x<2>, x<3>)), permutations(list(x<1>, x<2>, x<3>))));
 }
diff --git a/test/traversable/sequence.cpp b/test/traversable/sequence.cpp
index f5f893057..704f7432e 100644
--- a/test/traversable/sequence.cpp
+++ b/test/traversable/sequence.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/traversable/traverse_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/traversable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
@@ -19,7 +19,7 @@ void test() {
     constexpr auto applicative = detail::minimal::applicative<>;
     constexpr auto comparable = detail::minimal::comparable<>;
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         sequence<detail::minimal::Applicative<>>(traversable(applicative(comparable(1))))
             ==
         applicative(traversable(comparable(1)))
diff --git a/test/traversable/traverse.cpp b/test/traversable/traverse.cpp
index 1b6180d3e..4690381e3 100644
--- a/test/traversable/traverse.cpp
+++ b/test/traversable/traverse.cpp
@@ -6,11 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/traversable/traverse_mcd.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/minimal/applicative.hpp>
 #include <boost/hana/detail/minimal/comparable.hpp>
 #include <boost/hana/detail/minimal/traversable.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 
 #include <tuple>
 using namespace boost::hana;
@@ -25,7 +25,7 @@ void test() {
         return applicative(std::make_tuple(x));
     };
 
-    BOOST_HANA_STATIC_ASSERT(
+    BOOST_HANA_CONSTEXPR_ASSERT(
         traverse<detail::minimal::Applicative<>>(f, traversable(comparable(1)))
             ==
         applicative(traversable(std::make_tuple(comparable(1))))
diff --git a/test/type/comparable/equal.cpp b/test/type/comparable/equal.cpp
index cbf70b410..2fdb57611 100644
--- a/test/type/comparable/equal.cpp
+++ b/test/type/comparable/equal.cpp
@@ -6,21 +6,21 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct T; struct U;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT( equal(type<T>, type<T>));
-    BOOST_HANA_STATIC_ASSERT(!equal(type<T>, type<U>));
-    BOOST_HANA_STATIC_ASSERT(!equal(type<void>, type<U>));
-    BOOST_HANA_STATIC_ASSERT(!equal(type<T>, type<void>));
-    BOOST_HANA_STATIC_ASSERT( equal(type<void>, type<void>));
+BOOST_HANA_CONSTANT_ASSERT( equal(type<T>, type<T>));
+BOOST_HANA_CONSTANT_ASSERT(!equal(type<T>, type<U>));
+BOOST_HANA_CONSTANT_ASSERT(!equal(type<void>, type<U>));
+BOOST_HANA_CONSTANT_ASSERT(!equal(type<T>, type<void>));
+BOOST_HANA_CONSTANT_ASSERT( equal(type<void>, type<void>));
 
-    BOOST_HANA_STATIC_ASSERT( equal(type<T&>, type<T&>));
-    BOOST_HANA_STATIC_ASSERT(!equal(type<T&>, type<T&&>));
-    BOOST_HANA_STATIC_ASSERT(!equal(type<T const>, type<T>));
-    BOOST_HANA_STATIC_ASSERT( equal(type<T const>, type<T const>));
-}
+BOOST_HANA_CONSTANT_ASSERT( equal(type<T&>, type<T&>));
+BOOST_HANA_CONSTANT_ASSERT(!equal(type<T&>, type<T&&>));
+BOOST_HANA_CONSTANT_ASSERT(!equal(type<T const>, type<T>));
+BOOST_HANA_CONSTANT_ASSERT( equal(type<T const>, type<T const>));
+
+int main() { }
diff --git a/test/type/comparable/laws.cpp b/test/type/comparable/laws.cpp
index fa31604f3..9aa6987a9 100644
--- a/test/type/comparable/laws.cpp
+++ b/test/type/comparable/laws.cpp
@@ -7,15 +7,15 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/type.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
 
 struct T; struct U;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
-        list(type<T>, type<U>, type<void>, type<int>, type<int&>)
-    ));
-}
+BOOST_HANA_CONSTANT_ASSERT(Comparable::laws::check(
+    list(type<T>, type<U>, type<void>, type<int>, type<int&>)
+));
+
+int main() { }
diff --git a/test/type/construct.cpp b/test/type/construct.cpp
index 4c35da32b..b7fa6acec 100644
--- a/test/type/construct.cpp
+++ b/test/type/construct.cpp
@@ -6,9 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 
-#include <cassert>
 #include <initializer_list>
 #include <utility>
 #include <vector>
@@ -16,14 +15,13 @@ using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(type<int>() == int{});
-    BOOST_HANA_STATIC_ASSERT(type<int>(2) == int{2});
-    BOOST_HANA_STATIC_ASSERT(type<float>(2.42f) == float{2.42});
-    BOOST_HANA_STATIC_ASSERT(type<double>(2.42) == double{2.42});
-    BOOST_HANA_STATIC_ASSERT(type<double>(2.2f) == double{2.2f});
-    BOOST_HANA_STATIC_ASSERT(type<float>(2.2) == float{2.2});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<int>() == int{});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<int>(2) == int{2});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<float>(2.42f) == float{2.42});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<double>(2.42) == double{2.42});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<double>(2.2f) == double{2.2f});
+    BOOST_HANA_CONSTEXPR_ASSERT(type<float>(2.2) == float{2.2});
 
-    // double parentheses are because `assert` is a macro
-    assert((type<std::vector<int>>(std::initializer_list<int>{1, 2, 3}) == std::vector<int>{1, 2, 3}));
-    assert((type<std::pair<int, char>>(1, '2') == std::make_pair(1, '2')));
+    BOOST_HANA_RUNTIME_ASSERT(type<std::vector<int>>(std::initializer_list<int>{1, 2, 3}) == std::vector<int>{1, 2, 3});
+    BOOST_HANA_RUNTIME_ASSERT(type<std::pair<int, char>>(1, '2') == std::make_pair(1, '2'));
 }
diff --git a/test/type/decltype.cpp b/test/type/decltype.cpp
index c89725f6e..b7cc43464 100644
--- a/test/type/decltype.cpp
+++ b/test/type/decltype.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct x { };
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(decltype_(1) == type<int>);
-    BOOST_HANA_STATIC_ASSERT(decltype_('1') == type<char>);
-    BOOST_HANA_STATIC_ASSERT(decltype_(x{}) == type<x>);
-}
+BOOST_HANA_CONSTANT_ASSERT(decltype_(1) == type<int>);
+BOOST_HANA_CONSTANT_ASSERT(decltype_('1') == type<char>);
+BOOST_HANA_CONSTANT_ASSERT(decltype_(x{}) == type<x>);
+
+int main() { }
diff --git a/test/type/quotes/metafunction.cpp b/test/type/quotes/metafunction.cpp
index 7bb18601c..91beec607 100644
--- a/test/type/quotes/metafunction.cpp
+++ b/test/type/quotes/metafunction.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
 #include <type_traits>
@@ -17,10 +17,10 @@ struct x1; struct x2; struct x3;
 
 template <template <typename ...> class f>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(metafunction<f>() == type<typename f<>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction<f>(type<x1>) == type<typename f<x1>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction<f>(type<x1>, type<x2>) == type<typename f<x1, x2>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction<f>(type<x1>, type<x2>, type<x3>) == type<typename f<x1, x2, x3>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction<f>() == type<typename f<>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction<f>(type<x1>) == type<typename f<x1>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction<f>(type<x1>, type<x2>) == type<typename f<x1, x2>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction<f>(type<x1>, type<x2>, type<x3>) == type<typename f<x1, x2, x3>::type>);
 
     using F = decltype(metafunction<f>);
     static_assert(std::is_same<typename F::template apply<>, f<>>::value, "");
@@ -38,6 +38,6 @@ using alias = f<x, y, z>;
 int main() {
     test<f>();
 
-    // BOOST_HANA_STATIC_ASSERT(!detail::is_valid(metafunction<invalid>)(type<x1>));
+    // BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(metafunction<invalid>)(type<x1>));
     // test<alias>();
 }
diff --git a/test/type/quotes/metafunction_class.cpp b/test/type/quotes/metafunction_class.cpp
index c02fdefee..01f09523a 100644
--- a/test/type/quotes/metafunction_class.cpp
+++ b/test/type/quotes/metafunction_class.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
 #include <type_traits>
@@ -17,10 +17,10 @@ struct x1; struct x2; struct x3;
 
 template <typename f>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(metafunction_class<f>() == type<typename f::template apply<>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction_class<f>(type<x1>) == type<typename f::template apply<x1>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction_class<f>(type<x1>, type<x2>) == type<typename f::template apply<x1, x2>::type>);
-    BOOST_HANA_STATIC_ASSERT(metafunction_class<f>(type<x1>, type<x2>, type<x3>) == type<typename f::template apply<x1, x2, x3>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction_class<f>() == type<typename f::template apply<>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction_class<f>(type<x1>) == type<typename f::template apply<x1>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction_class<f>(type<x1>, type<x2>) == type<typename f::template apply<x1, x2>::type>);
+    BOOST_HANA_CONSTANT_ASSERT(metafunction_class<f>(type<x1>, type<x2>, type<x3>) == type<typename f::template apply<x1, x2, x3>::type>);
 
     using F = decltype(metafunction_class<f>);
     static_assert(std::is_same<typename F::template apply<>, typename f::template apply<>>::value, "");
@@ -41,5 +41,5 @@ int main() {
     test<f>();
 
     // test<alias>();
-    // BOOST_HANA_STATIC_ASSERT(!detail::is_valid(metafunction_class<invalid>)(type<x1>));
+    // BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(metafunction_class<invalid>)(type<x1>));
 }
diff --git a/test/type/quotes/template.cpp b/test/type/quotes/template.cpp
index 24638ea07..16ca56312 100644
--- a/test/type/quotes/template.cpp
+++ b/test/type/quotes/template.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
 #include <type_traits>
@@ -17,10 +17,10 @@ struct x1; struct x2; struct x3;
 
 template <template <typename ...> class f>
 void test() {
-    BOOST_HANA_STATIC_ASSERT(template_<f>() == type<f<>>);
-    BOOST_HANA_STATIC_ASSERT(template_<f>(type<x1>) == type<f<x1>>);
-    BOOST_HANA_STATIC_ASSERT(template_<f>(type<x1>, type<x2>) == type<f<x1, x2>>);
-    BOOST_HANA_STATIC_ASSERT(template_<f>(type<x1>, type<x2>, type<x3>) == type<f<x1, x2, x3>>);
+    BOOST_HANA_CONSTANT_ASSERT(template_<f>() == type<f<>>);
+    BOOST_HANA_CONSTANT_ASSERT(template_<f>(type<x1>) == type<f<x1>>);
+    BOOST_HANA_CONSTANT_ASSERT(template_<f>(type<x1>, type<x2>) == type<f<x1, x2>>);
+    BOOST_HANA_CONSTANT_ASSERT(template_<f>(type<x1>, type<x2>, type<x3>) == type<f<x1, x2, x3>>);
 
     using F = decltype(template_<f>);
     static_assert(std::is_same<typename F::template apply<>::type, f<>>::value, "");
@@ -40,6 +40,6 @@ using alias = f<x, y, z>;
 int main() {
     test<f>();
 
-    // BOOST_HANA_STATIC_ASSERT(!detail::is_valid(template_<invalid>)(type<x1>));
+    // BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(template_<invalid>)(type<x1>));
     // test<alias>();
 }
diff --git a/test/type/quotes/trait.cpp b/test/type/quotes/trait.cpp
index d8b066b65..7ac24fb7d 100644
--- a/test/type/quotes/trait.cpp
+++ b/test/type/quotes/trait.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
 #include <type_traits>
@@ -41,5 +40,5 @@ int main() {
     test<f>();
 
     // test<alias>();
-    // BOOST_HANA_STATIC_ASSERT(!detail::is_valid(trait<invalid>)(type<x1>));
+    // BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(trait<invalid>)(type<x1>));
 }
diff --git a/test/type/quotes/trait_.cpp b/test/type/quotes/trait_.cpp
index f3269ebdf..7629e883f 100644
--- a/test/type/quotes/trait_.cpp
+++ b/test/type/quotes/trait_.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/sandbox/detail/is_valid.hpp>
 
 #include <type_traits>
@@ -40,5 +39,5 @@ int main() {
     test<f>();
 
     // test<alias>();
-    // BOOST_HANA_STATIC_ASSERT(!detail::is_valid(trait_<invalid>)(x1{}));
+    // BOOST_HANA_CONSTANT_ASSERT(!detail::is_valid(trait_<invalid>)(x1{}));
 }
diff --git a/test/type/sizeof.cpp b/test/type/sizeof.cpp
index 1e7c2f19a..0719514a2 100644
--- a/test/type/sizeof.cpp
+++ b/test/type/sizeof.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
-int main() {
-    struct X { };
-    BOOST_HANA_STATIC_ASSERT(sizeof_(type<int>) == size_t<sizeof(int)>);
-    BOOST_HANA_STATIC_ASSERT(sizeof_(type<X>) == size_t<sizeof(X)>);
-    BOOST_HANA_STATIC_ASSERT(sizeof_(type<X>) == size_t<sizeof(X{})>);
-}
+struct X { };
+BOOST_HANA_CONSTANT_ASSERT(sizeof_(type<int>) == size_t<sizeof(int)>);
+BOOST_HANA_CONSTANT_ASSERT(sizeof_(type<X>) == size_t<sizeof(X)>);
+BOOST_HANA_CONSTANT_ASSERT(sizeof_(type<X>) == size_t<sizeof(X{})>);
+
+int main() { }
diff --git a/test/type_list/comparable/equal.cpp b/test/type_list/comparable/equal.cpp
index 3b6dc310f..30770adb4 100644
--- a/test/type_list/comparable/equal.cpp
+++ b/test/type_list/comparable/equal.cpp
@@ -6,19 +6,19 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct x0; struct x1; struct x2;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(type_list<> == type_list<>);
-    BOOST_HANA_STATIC_ASSERT(!(type_list<x0> == type_list<>));
-    BOOST_HANA_STATIC_ASSERT(!(type_list<> == type_list<x0>));
-    BOOST_HANA_STATIC_ASSERT(type_list<x0> == type_list<x0>);
-    BOOST_HANA_STATIC_ASSERT(!(type_list<x0, x1> == type_list<x0>));
-    BOOST_HANA_STATIC_ASSERT(!(type_list<x0> == type_list<x0, x1>));
-    BOOST_HANA_STATIC_ASSERT(type_list<x0, x1> == type_list<x0, x1>);
-    BOOST_HANA_STATIC_ASSERT(type_list<x0, x1, x2> == type_list<x0, x1, x2>);
-}
+BOOST_HANA_CONSTANT_ASSERT(type_list<> == type_list<>);
+BOOST_HANA_CONSTANT_ASSERT(!(type_list<x0> == type_list<>));
+BOOST_HANA_CONSTANT_ASSERT(!(type_list<> == type_list<x0>));
+BOOST_HANA_CONSTANT_ASSERT(type_list<x0> == type_list<x0>);
+BOOST_HANA_CONSTANT_ASSERT(!(type_list<x0, x1> == type_list<x0>));
+BOOST_HANA_CONSTANT_ASSERT(!(type_list<x0> == type_list<x0, x1>));
+BOOST_HANA_CONSTANT_ASSERT(type_list<x0, x1> == type_list<x0, x1>);
+BOOST_HANA_CONSTANT_ASSERT(type_list<x0, x1, x2> == type_list<x0, x1, x2>);
+
+int main() { }
diff --git a/test/type_list/comparable/laws.cpp b/test/type_list/comparable/laws.cpp
index 7a83fe34f..34da3a34b 100644
--- a/test/type_list/comparable/laws.cpp
+++ b/test/type_list/comparable/laws.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/type_list.hpp>
 
 #include <boost/hana/comparable/laws.hpp>
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/list/instance.hpp>
 using namespace boost::hana;
 
@@ -18,13 +18,13 @@ struct x;
 template <int ...i>
 constexpr auto tlist = type_list<x<i>...>;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(Comparable::laws::check(
-        list(
-            tlist<>,
-            tlist<0>,
-            tlist<0, 1>,
-            tlist<0, 1, 2>
-        )
-    ));
-}
+BOOST_HANA_CONSTANT_ASSERT(Comparable::laws::check(
+    list(
+        tlist<>,
+        tlist<0>,
+        tlist<0, 1>,
+        tlist<0, 1, 2>
+    )
+));
+
+int main() { }
diff --git a/test/type_list/foldable/foldl.cpp b/test/type_list/foldable/foldl.cpp
index 07c014c47..9e04e16bc 100644
--- a/test/type_list/foldable/foldl.cpp
+++ b/test/type_list/foldable/foldl.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/type.hpp>
 
 #include <tuple>
@@ -25,13 +25,13 @@ constexpr auto g = template_<G>;
 
 int main() {
     constexpr auto s = type<x0>;
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, type_list<>) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, type_list<x1>) == f(s, type<x1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, type_list<x1, x2>) == f(f(s, type<x1>), type<x2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(f, s, type_list<x1, x2, x3>) == f(f(f(s, type<x1>), type<x2>), type<x3>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(f, s, type_list<>) == s);
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, type_list<x1>) == f(s, type<x1>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, type_list<x1, x2>) == f(f(s, type<x1>), type<x2>));
+    BOOST_HANA_CONSTEXPR_ASSERT(foldl(f, s, type_list<x1, x2, x3>) == f(f(f(s, type<x1>), type<x2>), type<x3>));
 
-    BOOST_HANA_STATIC_ASSERT(foldl(g, s, type_list<>) == s);
-    BOOST_HANA_STATIC_ASSERT(foldl(g, s, type_list<x1>) == g(s, type<x1>));
-    BOOST_HANA_STATIC_ASSERT(foldl(g, s, type_list<x1, x2>) == g(g(s, type<x1>), type<x2>));
-    BOOST_HANA_STATIC_ASSERT(foldl(g, s, type_list<x1, x2, x3>) == g(g(g(s, type<x1>), type<x2>), type<x3>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(g, s, type_list<>) == s);
+    BOOST_HANA_CONSTANT_ASSERT(foldl(g, s, type_list<x1>) == g(s, type<x1>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(g, s, type_list<x1, x2>) == g(g(s, type<x1>), type<x2>));
+    BOOST_HANA_CONSTANT_ASSERT(foldl(g, s, type_list<x1, x2, x3>) == g(g(g(s, type<x1>), type<x2>), type<x3>));
 }
diff --git a/test/type_list/iterable/head.cpp b/test/type_list/iterable/head.cpp
index 63e552d6e..c4f6aec0d 100644
--- a/test/type_list/iterable/head.cpp
+++ b/test/type_list/iterable/head.cpp
@@ -6,15 +6,15 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
 
 struct x0; struct x1; struct x2;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(head(type_list<x0>) == type<x0>);
-    BOOST_HANA_STATIC_ASSERT(head(type_list<x0, x1>) == type<x0>);
-    BOOST_HANA_STATIC_ASSERT(head(type_list<x0, x1, x2>) == type<x0>);
-}
+BOOST_HANA_CONSTANT_ASSERT(head(type_list<x0>) == type<x0>);
+BOOST_HANA_CONSTANT_ASSERT(head(type_list<x0, x1>) == type<x0>);
+BOOST_HANA_CONSTANT_ASSERT(head(type_list<x0, x1, x2>) == type<x0>);
+
+int main() { }
diff --git a/test/type_list/iterable/is_empty.cpp b/test/type_list/iterable/is_empty.cpp
index 1e57e9b35..8edba3750 100644
--- a/test/type_list/iterable/is_empty.cpp
+++ b/test/type_list/iterable/is_empty.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct x0; struct x1; struct x2;
 
-int main() {
-    BOOST_HANA_STATIC_ASSERT(is_empty(type_list<>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(type_list<x0>));
-    BOOST_HANA_STATIC_ASSERT(!is_empty(type_list<x0, x1>));
-}
+BOOST_HANA_CONSTANT_ASSERT(is_empty(type_list<>));
+BOOST_HANA_CONSTANT_ASSERT(!is_empty(type_list<x0>));
+BOOST_HANA_CONSTANT_ASSERT(!is_empty(type_list<x0, x1>));
+
+int main() { }
diff --git a/test/type_list/iterable/tail.cpp b/test/type_list/iterable/tail.cpp
index 5ab5cf3cb..a6e9ce85b 100644
--- a/test/type_list/iterable/tail.cpp
+++ b/test/type_list/iterable/tail.cpp
@@ -6,14 +6,14 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(tail(type_list<x0>) == type_list<>);
-    BOOST_HANA_STATIC_ASSERT(tail(type_list<x0, x1>) == type_list<x1>);
-    BOOST_HANA_STATIC_ASSERT(tail(type_list<x0, x1, x2>) == type_list<x1, x2>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(type_list<x0>) == type_list<>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(type_list<x0, x1>) == type_list<x1>);
+    BOOST_HANA_CONSTANT_ASSERT(tail(type_list<x0, x1, x2>) == type_list<x1, x2>);
 }
diff --git a/test/type_list/list/cons.cpp b/test/type_list/list/cons.cpp
index 9f1c97518..6403a6d15 100644
--- a/test/type_list/list/cons.cpp
+++ b/test/type_list/list/cons.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
 
@@ -14,7 +14,7 @@ using namespace boost::hana;
 struct x0; struct x1; struct x2;
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, type_list<>) == type_list<x0>);
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, type_list<x1>) == type_list<x0, x1>);
-    BOOST_HANA_STATIC_ASSERT(cons(type<x0>, type_list<x1, x2>) == type_list<x0, x1, x2>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(type<x0>, type_list<>) == type_list<x0>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(type<x0>, type_list<x1>) == type_list<x0, x1>);
+    BOOST_HANA_CONSTANT_ASSERT(cons(type<x0>, type_list<x1, x2>) == type_list<x0, x1, x2>);
 }
diff --git a/test/type_list/list/nil.cpp b/test/type_list/list/nil.cpp
index ddfc44691..b2b76b32b 100644
--- a/test/type_list/list/nil.cpp
+++ b/test/type_list/list/nil.cpp
@@ -6,10 +6,10 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/type_list.hpp>
 
-#include <boost/hana/detail/static_assert.hpp>
+#include <boost/hana/detail/assert.hpp>
 using namespace boost::hana;
 
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(nil<TypeList> == type_list<>);
+    BOOST_HANA_CONSTANT_ASSERT(nil<TypeList> == type_list<>);
 }