diff --git a/include/boost/hana/comparable.hpp b/include/boost/hana/comparable.hpp
index 2a9cbbb7d..832fbd56c 100644
--- a/include/boost/hana/comparable.hpp
+++ b/include/boost/hana/comparable.hpp
@@ -13,6 +13,7 @@
 #define BOOST_HANA_COMPARABLE_HPP
 
 #include <boost/hana/core.hpp>
+#include <boost/hana/detail/constexpr.hpp>
 
 
 namespace boost { namespace hana {
@@ -20,17 +21,13 @@ namespace boost { namespace hana {
     template <typename T, typename U>
     struct Comparable;
 
-    constexpr struct _equal {
-        template <typename T, typename U>
-        constexpr auto operator()(T t, U u) const
-        { return Comparable<T, U>::equal_impl(t, u); }
-    } equal{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto equal = [](auto x, auto y) {
+        return Comparable<decltype(x), decltype(y)>::equal_impl(x, y);
+    };
 
-    constexpr struct _not_equal {
-        template <typename T, typename U>
-        constexpr auto operator()(T t, U u) const
-        { return Comparable<T, U>::not_equal_impl(t, u); }
-    } not_equal{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto not_equal = [](auto x, auto y) {
+        return Comparable<decltype(x), decltype(y)>::not_equal_impl(x, y);
+    };
 
     template <>
     struct defaults<Comparable> {
diff --git a/include/boost/hana/detail/constexpr.hpp b/include/boost/hana/detail/constexpr.hpp
new file mode 100644
index 000000000..b485c5e19
--- /dev/null
+++ b/include/boost/hana/detail/constexpr.hpp
@@ -0,0 +1,22 @@
+/*!
+ * @file
+ * Defines the `BOOST_HANA_CONSTEXPR_LAMBDA` macro.
+ *
+ *
+ * @copyright Louis Dionne 2014
+ * Distributed under the Boost Software License, Version 1.0.
+ *         (See accompanying file LICENSE.md or copy at
+ *             http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_HANA_DETAIL_CONSTEXPR_HPP
+#define BOOST_HANA_DETAIL_CONSTEXPR_HPP
+
+/*!
+ * @ingroup details
+ * Expands to `constexpr` if constexpr lambdas are supported and
+ * to `const` otherwise.
+ */
+#define BOOST_HANA_CONSTEXPR_LAMBDA const
+
+#endif // !BOOST_HANA_DETAIL_CONSTEXPR_HPP
\ No newline at end of file
diff --git a/include/boost/hana/foldable.hpp b/include/boost/hana/foldable.hpp
index dc535d5b9..3475ffbb5 100644
--- a/include/boost/hana/foldable.hpp
+++ b/include/boost/hana/foldable.hpp
@@ -13,6 +13,7 @@
 #define BOOST_HANA_FOLDABLE_HPP
 
 #include <boost/hana/core.hpp>
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/logical.hpp>
 
@@ -22,65 +23,47 @@ namespace boost { namespace hana {
     template <typename T>
     struct Foldable;
 
-    constexpr struct _foldl {
-        template <typename F, typename State, typename Foldable_>
-        constexpr auto operator()(F f, State s, Foldable_ foldable) const
-        { return Foldable<Foldable_>::foldl_impl(f, s, foldable); }
-    } foldl{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto foldl = [](auto f, auto state, auto foldable) {
+        return Foldable<decltype(foldable)>::foldl_impl(f, state, foldable);
+    };
 
-    constexpr struct _foldr {
-        template <typename F, typename State, typename Foldable_>
-        constexpr auto operator()(F f, State s, Foldable_ foldable) const
-        { return Foldable<Foldable_>::foldr_impl(f, s, foldable); }
-    } foldr{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto foldr = [](auto f, auto state, auto foldable) {
+        return Foldable<decltype(foldable)>::foldr_impl(f, state, foldable);
+    };
 
-    constexpr struct _foldr1 {
-        template <typename F, typename Foldable_>
-        constexpr auto operator()(F f, Foldable_ foldable) const
-        { return Foldable<Foldable_>::foldr1_impl(f, foldable); }
-    } foldr1{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto foldr1 = [](auto f, auto foldable) {
+        return Foldable<decltype(foldable)>::foldr1_impl(f, foldable);
+    };
 
-    constexpr struct _foldl1 {
-        template <typename F, typename Foldable_>
-        constexpr auto operator()(F f, Foldable_ foldable) const
-        { return Foldable<Foldable_>::foldl1_impl(f, foldable); }
-    } foldl1{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto foldl1 = [](auto f, auto foldable) {
+        return Foldable<decltype(foldable)>::foldl1_impl(f, foldable);
+    };
 
-    constexpr struct _minimum {
-        template <typename Foldable_>
-        constexpr auto operator()(Foldable_ foldable) const
-        { return Foldable<Foldable_>::minimum_impl(foldable); }
-    } minimum{};
 
-    constexpr struct _maximum {
-        template <typename Foldable_>
-        constexpr auto operator()(Foldable_ foldable) const
-        { return Foldable<Foldable_>::maximum_impl(foldable); }
-    } maximum{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto minimum_by = [](auto pred, auto foldable) {
+        return Foldable<decltype(foldable)>::minimum_by_impl(pred, foldable);
+    };
 
-    constexpr struct _maximum_by {
-        template <typename Pred, typename Foldable_>
-        constexpr auto operator()(Pred pred, Foldable_ foldable) const
-        { return Foldable<Foldable_>::maximum_by_impl(pred, foldable); }
-    } maximum_by{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto minimum = [](auto foldable) {
+        return Foldable<decltype(foldable)>::minimum_impl(foldable);
+    };
 
-    constexpr struct _minimum_by {
-        template <typename Pred, typename Foldable_>
-        constexpr auto operator()(Pred pred, Foldable_ foldable) const
-        { return Foldable<Foldable_>::minimum_by_impl(pred, foldable); }
-    } minimum_by{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto maximum_by = [](auto pred, auto foldable) {
+        return Foldable<decltype(foldable)>::maximum_by_impl(pred, foldable);
+    };
 
-    constexpr struct _sum {
-        template <typename Foldable_>
-        constexpr auto operator()(Foldable_ foldable) const
-        { return Foldable<Foldable_>::sum_impl(foldable); }
-    } sum{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto maximum = [](auto foldable) {
+        return Foldable<decltype(foldable)>::maximum_impl(foldable);
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto sum = [](auto foldable) {
+        return Foldable<decltype(foldable)>::sum_impl(foldable);
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto product = [](auto foldable) {
+        return Foldable<decltype(foldable)>::product_impl(foldable);
+    };
 
-    constexpr struct _product {
-        template <typename Foldable_>
-        constexpr auto operator()(Foldable_ foldable) const
-        { return Foldable<Foldable_>::product_impl(foldable); }
-    } product{};
 
     template <>
     struct defaults<Foldable> {
diff --git a/include/boost/hana/functional.hpp b/include/boost/hana/functional.hpp
index df17da35c..4b56a3f94 100644
--- a/include/boost/hana/functional.hpp
+++ b/include/boost/hana/functional.hpp
@@ -12,6 +12,9 @@
 #ifndef BOOST_HANA_FUNCTIONAL_HPP
 #define BOOST_HANA_FUNCTIONAL_HPP
 
+#include <boost/hana/detail/constexpr.hpp>
+
+
 namespace boost { namespace hana {
     template <template <typename ...> class f>
     struct _lift {
@@ -22,72 +25,28 @@ namespace boost { namespace hana {
     template <template <typename ...> class f>
     constexpr auto lift = _lift<f>{};
 
-    constexpr struct _apply {
-        template <typename F, typename ...Args>
-        constexpr auto operator()(F f, Args ...args) const
-        { return f(args...); }
-    } apply{};
 
+    BOOST_HANA_CONSTEXPR_LAMBDA auto apply = [](auto f, auto ...xs) {
+        return f(xs...);
+    };
 
-    constexpr struct _always {
-    private:
-        template <typename X>
-        struct alwayser {
-            X x;
-            template <typename ...Y>
-            constexpr auto operator()(Y ...) const
-            { return x; }
-        };
+    BOOST_HANA_CONSTEXPR_LAMBDA auto always = [](auto x) {
+        return [=](auto ...y) { return x; };
+    };
 
-    public:
-        template <typename X>
-        constexpr auto operator()(X x) const
-        { return alwayser<X>{x}; }
-    } always{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto id = [](auto x) { return x; };
 
-    constexpr struct _id {
-        template <typename X>
-        constexpr auto operator()(X x) const
-        { return x; }
-    } id{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto compose = [](auto f, auto g) {
+        return [=](auto x, auto ...xs) { return f(g(x), xs...); };
+    };
 
-    constexpr struct _compose {
-    private:
-        template <typename F, typename G>
-        struct composer {
-            F f; G g;
-            template <typename X, typename ...Xs>
-            constexpr auto operator()(X x, Xs ...xs) const
-            { return f(g(x), xs...); }
-        };
+    BOOST_HANA_CONSTEXPR_LAMBDA auto flip = [](auto f) {
+        return [=](auto x, auto y, auto ...z) { return f(y, x, z...); };
+    };
 
-    public:
-        template <typename F, typename G>
-        constexpr auto operator()(F f, G g) const
-        { return composer<F, G>{f, g}; }
-    } compose{};
-
-    constexpr struct _flip {
-    private:
-        template <typename F>
-        struct flipper {
-            F f;
-            template <typename X, typename Y, typename ...Ys>
-            constexpr auto operator()(X x, Y y, Ys ...ys) const
-            { return f(y, x, ys...); }
-        };
-
-    public:
-        template <typename F>
-        constexpr flipper<F> operator()(F f) const
-        { return {f}; }
-    } flip{};
-
-    constexpr struct _partial {
-        template <typename F, typename ...Args>
-        constexpr auto operator()(F f, Args ...xs) const
-        { return [=](auto ...ys) { return f(xs..., ys...); }; }
-    } partial{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto partial = [](auto f, auto ...xs) {
+        return [=](auto ...ys) { return f(xs..., ys...); };
+    };
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTIONAL_HPP
diff --git a/include/boost/hana/functor.hpp b/include/boost/hana/functor.hpp
index 0a0bf1f71..f1b64d081 100644
--- a/include/boost/hana/functor.hpp
+++ b/include/boost/hana/functor.hpp
@@ -12,16 +12,17 @@
 #ifndef BOOST_HANA_FUNCTOR_HPP
 #define BOOST_HANA_FUNCTOR_HPP
 
+#include <boost/hana/detail/constexpr.hpp>
+
+
 namespace boost { namespace hana {
     //! @ingroup typeclasses
     template <typename T>
     struct Functor;
 
-    constexpr struct _fmap {
-        template <typename F, typename Functor_>
-        constexpr auto operator()(F f, Functor_ functor) const
-        { return Functor<Functor_>::fmap_impl(f, functor); }
-    } fmap{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto fmap = [](auto f, auto functor) {
+        return Functor<decltype(functor)>::fmap_impl(f, functor);
+    };
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FUNCTOR_HPP
diff --git a/include/boost/hana/iterable.hpp b/include/boost/hana/iterable.hpp
index 4aedf8516..f7ebcc126 100644
--- a/include/boost/hana/iterable.hpp
+++ b/include/boost/hana/iterable.hpp
@@ -13,6 +13,7 @@
 #define BOOST_HANA_ITERABLE_HPP
 
 #include <boost/hana/core.hpp>
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/logical.hpp>
@@ -23,83 +24,59 @@ namespace boost { namespace hana {
     template <typename T>
     struct Iterable;
 
-    constexpr struct _head {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::head_impl(iterable); }
-    } head{};
 
-    constexpr struct _tail {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::tail_impl(iterable); }
-    } tail{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto head = [](auto iterable) {
+        return Iterable<decltype(iterable)>::head_impl(iterable);
+    };
 
-    constexpr struct _is_empty {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::is_empty_impl(iterable); }
-    } is_empty{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto tail = [](auto iterable) {
+        return Iterable<decltype(iterable)>::tail_impl(iterable);
+    };
 
-    constexpr struct _at {
-        template <typename Index, typename Iterable_>
-        constexpr auto operator()(Index n, Iterable_ iterable) const
-        { return Iterable<Iterable_>::at_impl(n, iterable); }
-    } at{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto is_empty = [](auto iterable) {
+        return Iterable<decltype(iterable)>::is_empty_impl(iterable);
+    };
 
-    constexpr struct _last {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::last_impl(iterable); }
-    } last{};
 
-    constexpr struct _length {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::length_impl(iterable); }
-    } length{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto at = [](auto n, auto iterable) {
+        return Iterable<decltype(iterable)>::at_impl(n, iterable);
+    };
 
-    constexpr struct _drop {
-        template <typename N, typename Iterable_>
-        constexpr auto operator()(N n, Iterable_ iterable) const
-        { return Iterable<Iterable_>::drop_impl(n, iterable); }
-    } drop{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto last = [](auto iterable) {
+        return Iterable<decltype(iterable)>::last_impl(iterable);
+    };
 
-    constexpr struct _any {
-        template <typename Pred, typename Iterable_>
-        constexpr auto operator()(Pred pred, Iterable_ iterable) const
-        { return Iterable<Iterable_>::any_impl(pred, iterable); }
-    } any{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto length = [](auto iterable) {
+        return Iterable<decltype(iterable)>::length_impl(iterable);
+    };
 
-    constexpr struct _any_of {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::any_of_impl(iterable); }
-    } any_of{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto drop = [](auto n, auto iterable) {
+        return Iterable<decltype(iterable)>::drop_impl(n, iterable);
+    };
 
-    constexpr struct _all {
-        template <typename Pred, typename Iterable_>
-        constexpr auto operator()(Pred pred, Iterable_ iterable) const
-        { return Iterable<Iterable_>::all_impl(pred, iterable); }
-    } all{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto any = [](auto pred, auto iterable) {
+        return Iterable<decltype(iterable)>::any_impl(pred, iterable);
+    };
 
-    constexpr struct _all_of {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::all_of_impl(iterable); }
-    } all_of{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto any_of = [](auto iterable) {
+        return Iterable<decltype(iterable)>::any_of_impl(iterable);
+    };
 
-    constexpr struct _none {
-        template <typename Pred, typename Iterable_>
-        constexpr auto operator()(Pred pred, Iterable_ iterable) const
-        { return Iterable<Iterable_>::none_impl(pred, iterable); }
-    } none{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto all = [](auto pred, auto iterable) {
+        return Iterable<decltype(iterable)>::all_impl(pred, iterable);
+    };
 
-    constexpr struct _none_of {
-        template <typename Iterable_>
-        constexpr auto operator()(Iterable_ iterable) const
-        { return Iterable<Iterable_>::none_of_impl(iterable); }
-    } none_of{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto all_of = [](auto iterable) {
+        return Iterable<decltype(iterable)>::all_of_impl(iterable);
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto none = [](auto pred, auto iterable) {
+        return Iterable<decltype(iterable)>::none_impl(pred, iterable);
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto none_of = [](auto iterable) {
+        return Iterable<decltype(iterable)>::none_of_impl(iterable);
+    };
 
 
     template <>
diff --git a/include/boost/hana/list.hpp b/include/boost/hana/list.hpp
index f0a66860a..93cc02091 100644
--- a/include/boost/hana/list.hpp
+++ b/include/boost/hana/list.hpp
@@ -14,6 +14,7 @@
 
 #include <boost/hana/comparable.hpp>
 #include <boost/hana/detail/comparable_from_iterable.hpp>
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/foldable_from_iterable.hpp>
 #include <boost/hana/foldable.hpp>
 #include <boost/hana/functional.hpp>
@@ -36,17 +37,15 @@ namespace boost { namespace hana {
         std::tuple<Xs...> storage_;
     };
 
-    constexpr struct _list {
-        template <typename ...Xs>
-        constexpr List<Xs...> operator()(Xs... xs) const
-        { return {{xs...}}; }
-    } list{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto list = [](auto ...xs) {
+        return List<decltype(xs)...>{{xs...}};
+    };
 
     template <typename ...Xs>
-    constexpr auto list_t = list(type<Xs>...);
+    BOOST_HANA_CONSTEXPR_LAMBDA auto list_t = list(type<Xs>...);
 
     template <typename T, T ...xs>
-    constexpr auto list_c = list(Integral<T, xs>{}...);
+    BOOST_HANA_CONSTEXPR_LAMBDA auto list_c = list(Integral<T, xs>{}...);
 
     template <typename ...Xs>
     struct Iterable<List<Xs...>> : defaults<Iterable> {
@@ -101,49 +100,48 @@ namespace boost { namespace hana {
 #include <boost/hana/range.hpp>
 
 namespace boost { namespace hana {
-    constexpr struct _zip_with {
-        template <typename F, typename ...Lists>
-        constexpr auto operator()(F f, Lists ...lists) const {
-            return fmap(
-                [=](auto index) { return f(at(index, lists)...); },
-                range(size_t<0>, minimum(list(length(lists)...)))
-            );
-        }
-    } zip_with{};
+    namespace list_detail {
+        template <typename ...Xs>
+        static constexpr List<Xs...> from_tuple(std::tuple<Xs...> tuple)
+        { return {tuple}; }
 
-    constexpr struct _zip {
-        template <typename ...Lists>
-        constexpr auto operator()(Lists ...lists) const
-        { return zip_with(list, lists...); }
-    } zip{};
-
-    constexpr struct _cons {
-        template <typename X, typename ...Xs>
-        constexpr List<X, Xs...> operator()(X x, List<Xs...> xs) const
-        { return {std::tuple_cat(std::make_tuple(x), xs.storage_)}; }
-    } cons{};
-
-    constexpr struct _snoc {
-        template <typename ...Xs, typename X>
-        constexpr List<Xs..., X> operator()(List<Xs...> xs, X x) const
-        { return {std::tuple_cat(xs.storage_, std::make_tuple(x))}; }
-    } snoc{};
-
-    constexpr struct _take {
+        //! @todo Remove this hack.
         template <typename T, T t>
         static constexpr SizeT<t> to_size_t(Integral<T, t>)
         { return {}; }
+    }
 
-        template <typename N, typename ...Xs>
-        constexpr auto operator()(N n, List<Xs...> xs) const {
-            auto min = [](auto a, auto b) { return if_(a < b, a, b); };
-            return fmap(
-                [=](auto index) { return at(index, xs); },
-                range(size_t<0>, min(to_size_t(n), length(xs)))
-            );
-        }
-    } take{};
 
+    BOOST_HANA_CONSTEXPR_LAMBDA auto zip_with = [](auto f, auto ...lists) {
+        return fmap(
+            [=](auto index) { return f(at(index, lists)...); },
+            range(size_t<0>, minimum(list(length(lists)...)))
+        );
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto zip = [](auto ...lists) {
+        return zip_with(list, lists...);
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto cons = [](auto x, auto xs) {
+        return list_detail::from_tuple(std::tuple_cat(std::make_tuple(x), xs.storage_));
+    };
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto snoc = [](auto xs, auto x) {
+        return list_detail::from_tuple(std::tuple_cat(xs.storage_, std::make_tuple(x)));
+    };
+
+
+    BOOST_HANA_CONSTEXPR_LAMBDA auto take = [](auto n, auto xs) {
+        auto min = [](auto a, auto b) { return if_(a < b, a, b); };
+        return fmap(
+            [=](auto index) { return at(index, xs); },
+            range(size_t<0>, list_detail::to_size_t(min(n, length(xs))))
+        );
+    };
+
+    // Can't use a lambda because of recursion.
+    //! @todo Use a Y-combinator :)
     constexpr struct _take_while {
         template <typename Pred, typename ...Xs>
         constexpr auto operator()(Pred p, List<Xs...> xs) const {
@@ -157,31 +155,20 @@ namespace boost { namespace hana {
         }
     } take_while{};
 
-    constexpr struct _reverse {
-        template <typename ...Xs>
-        constexpr auto operator()(List<Xs...> xs) const
-        { return foldl(flip(cons), list(), xs); }
-    } reverse{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto reverse = [](auto xs) {
+        return foldl(flip(cons), list(), xs);
+    };
 
-    constexpr struct _filter {
-        template <typename Pred, typename ...Xs>
-        constexpr auto operator()(Pred p, List<Xs...> xs) const {
-            auto go = [=](auto x, auto xs) {
-                return if_(p(x), cons(x, xs), xs);
-            };
-            return foldr(go, list(), xs);
-        }
-    } filter{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto filter = [](auto pred, auto xs) {
+        auto go = [=](auto x, auto xs) {
+            return if_(pred(x), cons, always(xs))(x, xs);
+        };
+        return foldr(go, list(), xs);
+    };
 
-    constexpr struct _concat {
-        template <typename ...Xs>
-        static constexpr List<Xs...> list_from_tuple(std::tuple<Xs...> tup)
-        { return {tup}; }
-
-        template <typename ...Lists>
-        constexpr auto operator()(Lists ...lists) const
-        { return list_from_tuple(std::tuple_cat(lists.storage_...)); }
-    } concat{};
+    BOOST_HANA_CONSTEXPR_LAMBDA auto concat = [](auto ...lists) {
+        return list_detail::from_tuple(std::tuple_cat(lists.storage_...));
+    };
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_LIST_HPP
diff --git a/test/detail/comparable_from_iterable.cpp b/test/detail/comparable_from_iterable.cpp
index 6a377e7b7..1911c4721 100644
--- a/test/detail/comparable_from_iterable.cpp
+++ b/test/detail/comparable_from_iterable.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/detail/comparable_from_iterable.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list.hpp>
 using namespace boost::hana;
 
 
-constexpr auto iterable = list; // minimal iterable
+BOOST_HANA_CONSTEXPR_LAMBDA auto iterable = list; // minimal iterable
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(equal(iterable(), iterable()));
diff --git a/test/detail/foldable_from_iterable.cpp b/test/detail/foldable_from_iterable.cpp
index 0deab9783..d9810c43e 100644
--- a/test/detail/foldable_from_iterable.cpp
+++ b/test/detail/foldable_from_iterable.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/detail/foldable_from_iterable.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list.hpp>
 using namespace boost::hana;
 
 
-constexpr auto iterable = list; // minimal iterable
+BOOST_HANA_CONSTEXPR_LAMBDA auto iterable = list; // minimal iterable
 
 void test_foldl() {
     BOOST_HANA_STATIC_ASSERT(foldl(list, int_<0>, iterable()) == int_<0>);
diff --git a/test/foldable.cpp b/test/foldable.cpp
index 633a8b390..0da7513bd 100644
--- a/test/foldable.cpp
+++ b/test/foldable.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/foldable.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list.hpp>
 using namespace boost::hana;
 
 
-constexpr auto foldable = list; // minimal foldable
+BOOST_HANA_CONSTEXPR_LAMBDA auto foldable = list; // minimal foldable
 
 void test_minimum() {
     BOOST_HANA_STATIC_ASSERT(minimum(foldable(int_<0>)) == int_<0>);
diff --git a/test/integral.cpp b/test/integral.cpp
index 849a05ad7..33532e3fd 100644
--- a/test/integral.cpp
+++ b/test/integral.cpp
@@ -10,6 +10,7 @@
 #include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
+
 void test_Comparable() {
     BOOST_HANA_STATIC_ASSERT(equal(int_<0>, int_<0>));
     BOOST_HANA_STATIC_ASSERT(!equal(int_<1>, int_<0>));
diff --git a/test/iterable.cpp b/test/iterable.cpp
index 21d594422..cb5f04ead 100644
--- a/test/iterable.cpp
+++ b/test/iterable.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/iterable.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 #include <boost/hana/list.hpp>
 using namespace boost::hana;
 
 
-constexpr auto iterable = list; // minimal iterable
+BOOST_HANA_CONSTEXPR_LAMBDA auto iterable = list; // minimal iterable
 
 void test_at() {
     BOOST_HANA_STATIC_ASSERT(at(int_<0>, iterable(int_<0>)) == int_<0>);
diff --git a/test/list/concat.cpp b/test/list/concat.cpp
index 02d02b528..bfe786940 100644
--- a/test/list/concat.cpp
+++ b/test/list/concat.cpp
@@ -7,12 +7,13 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(concat() == ilist<>);
diff --git a/test/list/cons.cpp b/test/list/cons.cpp
index 183b483b2..193e823c9 100644
--- a/test/list/cons.cpp
+++ b/test/list/cons.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(cons(int_<0>, list()) == ilist<0>);
diff --git a/test/list/filter.cpp b/test/list/filter.cpp
index e29c3274e..817ff6197 100644
--- a/test/list/filter.cpp
+++ b/test/list/filter.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 constexpr struct _odd {
     template <typename I>
diff --git a/test/list/reverse.cpp b/test/list/reverse.cpp
index f7f3cd076..e364bb19c 100644
--- a/test/list/reverse.cpp
+++ b/test/list/reverse.cpp
@@ -7,13 +7,13 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
-
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(reverse(ilist<>) == ilist<>);
diff --git a/test/list/snoc.cpp b/test/list/snoc.cpp
index 44922b50f..92e2da88b 100644
--- a/test/list/snoc.cpp
+++ b/test/list/snoc.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(snoc(list(), int_<0>) == ilist<0>);
diff --git a/test/list/take.cpp b/test/list/take.cpp
index dc0df36f0..166ab33dc 100644
--- a/test/list/take.cpp
+++ b/test/list/take.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(take(int_<0>, list()) == list());
diff --git a/test/list/take_while.cpp b/test/list/take_while.cpp
index 086e7ac7a..2de1f8c82 100644
--- a/test/list/take_while.cpp
+++ b/test/list/take_while.cpp
@@ -7,13 +7,14 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/integral.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 constexpr struct _odd {
     template <typename I>
diff --git a/test/list/zip.cpp b/test/list/zip.cpp
index 8fd35ad1e..6b8ee2760 100644
--- a/test/list/zip.cpp
+++ b/test/list/zip.cpp
@@ -7,12 +7,13 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(zip(list(), list()) == list());
diff --git a/test/list/zip_with.cpp b/test/list/zip_with.cpp
index b00df0ed2..0ff5adb39 100644
--- a/test/list/zip_with.cpp
+++ b/test/list/zip_with.cpp
@@ -7,20 +7,21 @@
 
 #include <boost/hana/list.hpp>
 
+#include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
-
-#include <functional>
 using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto ilist = list_c<int, i...>;
+BOOST_HANA_CONSTEXPR_LAMBDA auto ilist = list_c<int, i...>;
+
+BOOST_HANA_CONSTEXPR_LAMBDA auto plus = [](auto x, auto y) { return x + y; };
 
 int main() {
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, list(), list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, ilist<1>, list()) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, list(), ilist<3>) == list());
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, ilist<1>, ilist<3>) == ilist<1 + 3>);
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, ilist<1, 2>, ilist<3, 4>) == ilist<1 + 3, 2 + 4>);
-    BOOST_HANA_STATIC_ASSERT(zip_with(std::plus<>{}, ilist<1, 2, 3, 4>, ilist<5, 6, 7>) == ilist<1 + 5, 2 + 6, 3 + 7>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<>, ilist<>) == ilist<>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<1>, ilist<>) == ilist<>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<>, ilist<3>) == ilist<>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<1>, ilist<3>) == ilist<1 + 3>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<1, 2>, ilist<3, 4>) == ilist<1 + 3, 2 + 4>);
+    BOOST_HANA_STATIC_ASSERT(zip_with(plus, ilist<1, 2, 3, 4>, ilist<5, 6, 7>) == ilist<1 + 5, 2 + 6, 3 + 7>);
 }
diff --git a/test/std_array.cpp b/test/std_array.cpp
index 4ee3808fd..d9b909624 100644
--- a/test/std_array.cpp
+++ b/test/std_array.cpp
@@ -14,7 +14,7 @@ using namespace boost::hana;
 
 
 template <int ...i>
-constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
+ auto array = std::array<int, sizeof...(i)>{{i...}};
 
 int main() {
     BOOST_HANA_STATIC_ASSERT(is_empty(array<>));