diff --git a/brigand/algorithms/all.hpp b/brigand/algorithms/all.hpp
index f0cd842..33d792b 100644
--- a/brigand/algorithms/all.hpp
+++ b/brigand/algorithms/all.hpp
@@ -17,6 +17,11 @@ namespace brigand
 #if defined(BRIGAND_COMP_MSVC_2013) || defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL)
 namespace detail
 {
+    template <class P, class T>
+    struct all_helper : ::brigand::apply<P, T>
+    {
+    };
+
     template <bool...>
     struct bools_
     {
@@ -26,8 +31,8 @@ namespace detail
 
     template <template <class...> class Sequence, typename Predicate, typename... Ts>
     struct all_impl<Sequence<Ts...>, Predicate>
-        : std::is_same<bools_<true, ::brigand::apply<Predicate, Ts>::value...>,
-                       bools_<::brigand::apply<Predicate, Ts>::value..., true>>
+        : std::is_same<bools_<true, all_helper<Predicate, Ts>::value...>,
+                       bools_<all_helper<Predicate, Ts>::value..., true>>
     {
     };
 }
@@ -53,8 +58,8 @@ namespace detail
     struct all_impl<Sequence<T, Ts...>, Predicate>
     {
         static constexpr all_same tester{
-            static_cast<::brigand::apply<Predicate, T> *>(nullptr),
-            static_cast<::brigand::apply<Predicate, Ts> *>(nullptr)...};
+            static_cast< ::brigand::apply<Predicate, T> *>(nullptr),
+            static_cast< ::brigand::apply<Predicate, Ts> *>(nullptr)...};
         using type = bool_<(::brigand::apply<Predicate, T>::value != 0 && tester.value)>;
     };
 
diff --git a/brigand/algorithms/count.hpp b/brigand/algorithms/count.hpp
index 9d140f1..2fb6915 100644
--- a/brigand/algorithms/count.hpp
+++ b/brigand/algorithms/count.hpp
@@ -14,11 +14,13 @@ namespace brigand
 {
 namespace detail
 {
+#if defined(BRIGAND_COMP_GCC) || defined(BRIGAND_COMP_CLANG) // not MSVC
     constexpr std::size_t count_bools(bool const * const begin, bool const * const end,
                                       std::size_t n)
     {
         return begin == end ? n : detail::count_bools(begin + 1, end, n + *begin);
     }
+#endif
 
     template <bool... Bs>
     struct template_count_bools
@@ -71,29 +73,38 @@ namespace lazy
     struct count_if<S<Ts...>, Pred>
     {
         static constexpr bool s_v[] = {::brigand::apply<Pred, Ts>::type::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
     };
 
     template <template <typename...> class S, typename... Ts, template <typename...> class F>
     struct count_if<S<Ts...>, bind<F, _1>>
     {
         static constexpr bool s_v[] = {F<Ts>::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
     };
 
     template <template <typename...> class S, typename... Ts, template <typename...> class F>
     struct count_if<S<Ts...>, F<_1>>
     {
         static constexpr bool s_v[] = {F<Ts>::type::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
     };
 #else
+#if defined(BRIGAND_COMP_MSVC_2015)
     template <template <typename...> class S, typename... Ts, typename Pred>
     struct count_if<S<Ts...>, Pred>
-        : ::brigand::detail::template_count_bools<::brigand::apply<Pred, Ts>::value...>
+        : ::brigand::detail::template_count_bools< ::brigand::apply<Pred, Ts>::value...>
     {
     };
-
+#else
+    template <template <typename...> class S, typename... Ts, typename Pred>
+    struct count_if<S<Ts...>, Pred>
+    {
+        template <typename T>
+        using val_t = brigand::apply<Pred, T>;
+        using type = typename ::brigand::detail::template_count_bools<val_t<Ts>::value...>::type;
+    };
+#endif
 #endif
 }
 
diff --git a/brigand/algorithms/detail/non_null.hpp b/brigand/algorithms/detail/non_null.hpp
index 51b6dbb..35fe7e3 100644
--- a/brigand/algorithms/detail/non_null.hpp
+++ b/brigand/algorithms/detail/non_null.hpp
@@ -16,7 +16,7 @@ namespace detail
     // Default find-like predicate
 
     template <typename Args>
-	struct non_null_impl : bool_<Args::value != 0>{};
+  struct non_null_impl : bool_<Args::value != 0>{};
     using non_null = non_null_impl<_1>;
 }
 }
diff --git a/brigand/algorithms/find.hpp b/brigand/algorithms/find.hpp
index 1103423..e537e71 100644
--- a/brigand/algorithms/find.hpp
+++ b/brigand/algorithms/find.hpp
@@ -46,7 +46,7 @@ namespace lazy
     // reverse_find uses reverse and find :o
     template <typename Sequence, typename Predicate = detail::non_null>
     using reverse_find =
-        ::brigand::lazy::reverse<::brigand::find<brigand::reverse<Sequence>, Predicate>>;
+        ::brigand::lazy::reverse< ::brigand::find<brigand::reverse<Sequence>, Predicate>>;
 }
 
 template <typename Sequence, typename Predicate = detail::non_null>
diff --git a/brigand/algorithms/index_of.hpp b/brigand/algorithms/index_of.hpp
index 5fc5a99..2dd17b2 100644
--- a/brigand/algorithms/index_of.hpp
+++ b/brigand/algorithms/index_of.hpp
@@ -20,7 +20,7 @@ namespace detail
     struct index_if_impl
     {
         using type = ::brigand::size_t<size<Sequence>::value -
-                                       size<::brigand::find<Sequence, Predicate>>::value>;
+                                       size< ::brigand::find<Sequence, Predicate>>::value>;
     };
 
     template <class Sequence, typename Predicate, typename NotFoundType>
@@ -31,7 +31,7 @@ namespace detail
 } // namespace detail
 
 template <class Sequence, class Predicate, class NotFoundType = no_such_type_>
-using index_if = typename detail::index_if_impl<::brigand::found<Sequence, Predicate>::value,
+using index_if = typename detail::index_if_impl< ::brigand::found<Sequence, Predicate>::value,
                                                 Sequence, Predicate, NotFoundType>::type;
 
 template <class Sequence, typename T>
diff --git a/brigand/algorithms/merge.hpp b/brigand/algorithms/merge.hpp
index 1c17611..1a5da17 100644
--- a/brigand/algorithms/merge.hpp
+++ b/brigand/algorithms/merge.hpp
@@ -17,6 +17,11 @@ namespace brigand
 {
 namespace detail
 {
+    template <class Comp, class T1, class U>
+    struct merge_helper : ::brigand::apply<Comp, T1, U>
+    {
+    };
+
     template <class L, class Seq1, class Seq2, class Comp>
     struct merge_impl;
 
@@ -25,7 +30,7 @@ namespace detail
 
     template <class... R, class T0, class T1, class... Ts, class U, class... Us, class Comp>
     struct merge_insert<true, list<R...>, list<T0, T1, Ts...>, list<U, Us...>, Comp>
-        : merge_insert<::brigand::apply<Comp, T1, U>::value, list<R..., T0>, list<T1, Ts...>,
+        : merge_insert<merge_helper<Comp, T1, U>::value, list<R..., T0>, list<T1, Ts...>,
                        list<U, Us...>, Comp>
     {
     };
@@ -40,7 +45,7 @@ namespace detail
 
     template <class... R, class T, class... Ts, class U0, class U1, class... Us, class Comp>
     struct merge_insert<false, list<R...>, list<T, Ts...>, list<U0, U1, Us...>, Comp>
-        : merge_insert<::brigand::apply<Comp, T, U1>::value, list<R..., U0>, list<T, Ts...>,
+        : merge_insert<merge_helper<Comp, T, U1>::value, list<R..., U0>, list<T, Ts...>,
                        list<U1, Us...>, Comp>
     {
     };
@@ -59,7 +64,7 @@ namespace detail
     struct merge_impl<list<R...>, list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>,
                       list<U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, Us...>, Comp>
     {
-        using sub = merge_insert<::brigand::apply<Comp, T0, U0>::value, list<>,
+        using sub = merge_insert<merge_helper<Comp, T0, U0>::value, list<>,
                                  list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
                                  list<U0, U1, U2, U3, U4, U5, U6, U7, U8, U9>, Comp>;
         using type = typename merge_impl<append<list<R...>, typename sub::list>,
@@ -69,7 +74,7 @@ namespace detail
 
     template <class... R, class T, class... Ts, class U, class... Us, class Comp>
     struct merge_impl<list<R...>, list<T, Ts...>, list<U, Us...>, Comp>
-        : std::conditional<::brigand::apply<Comp, T, U>::value,
+        : std::conditional<merge_helper<Comp, T, U>::value,
                            merge_impl<list<R..., T>, list<Ts...>, list<U, Us...>, Comp>,
                            merge_impl<list<R..., U>, list<T, Ts...>, list<Us...>, Comp>>::type
     {
diff --git a/brigand/algorithms/none.hpp b/brigand/algorithms/none.hpp
index 4cc1382..92d82d1 100644
--- a/brigand/algorithms/none.hpp
+++ b/brigand/algorithms/none.hpp
@@ -13,7 +13,6 @@
 
 namespace brigand
 {
-
 #if defined(BRIGAND_COMP_MSVC_2013) || defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL)
 namespace detail
 {
@@ -26,7 +25,6 @@ namespace detail
             using that = brigand::apply<Pred, T>;
             using type = bool_<!that::value>;
         };
-
         using type = all<Sequence, nope<_1>>;
     };
 }
@@ -43,8 +41,8 @@ namespace detail
     struct none_impl<Sequence<T, Ts...>, Predicate>
     {
         static constexpr all_same tester{
-            static_cast<::brigand::apply<Predicate, T> *>(nullptr),
-            static_cast<::brigand::apply<Predicate, Ts> *>(nullptr)...};
+            static_cast< ::brigand::apply<Predicate, T> *>(nullptr),
+            static_cast< ::brigand::apply<Predicate, Ts> *>(nullptr)...};
         using type = bool_<(::brigand::apply<Predicate, T>::value == 0 && tester.value)>;
     };
 
diff --git a/brigand/algorithms/remove.hpp b/brigand/algorithms/remove.hpp
index 6fe7e7e..299e654 100644
--- a/brigand/algorithms/remove.hpp
+++ b/brigand/algorithms/remove.hpp
@@ -24,7 +24,7 @@ namespace lazy
     template <template <class...> class L, typename... Ts, typename Pred>
     struct remove_if<L<Ts...>, Pred>
         : ::brigand::detail::append_impl<
-              L<>, typename std::conditional<::brigand::apply<Pred, Ts>::value, list<>,
+              L<>, typename std::conditional< ::brigand::apply<Pred, Ts>::value, list<>,
                                              list<Ts>>::type...>
     {
     };
@@ -66,7 +66,7 @@ namespace lazy
     template <template <class...> class L, typename... Ts, typename Pred>
     struct filter<L<Ts...>, Pred>
         : ::brigand::detail::append_impl<
-              L<>, typename std::conditional<::brigand::apply<Pred, Ts>::value, list<Ts>,
+              L<>, typename std::conditional< ::brigand::apply<Pred, Ts>::value, list<Ts>,
                                              list<>>::type...>
     {
     };
@@ -88,9 +88,14 @@ namespace lazy
 #else
 namespace detail
 {
+    template <class Pred, class T>
+    struct empty_helper : ::brigand::apply<Pred, T>
+    {
+    };
+
     // this is essentially just a work around because MSVC can't expand variadic packs properly
     template <typename Pred, typename T, bool B>
-    struct empty_if_true : std::conditional<::brigand::apply<Pred, T>::value == B, list<>, list<T>>
+    struct empty_if_true : std::conditional<empty_helper<Pred, T>::value == B, list<>, list<T>>
     {
     };
     template <template <typename...> class F, typename T, bool B>
diff --git a/brigand/algorithms/replace.hpp b/brigand/algorithms/replace.hpp
index 767a0ea..9309b26 100644
--- a/brigand/algorithms/replace.hpp
+++ b/brigand/algorithms/replace.hpp
@@ -16,8 +16,14 @@ namespace brigand
 //#ifdef BRIGAND_COMP_MSVC
 namespace detail
 {
+    template <typename Pred, typename T>
+    struct rep_helper
+    {
+        using type = brigand::apply<Pred, T>;
+    };
+
     template <typename T, typename Pred, typename NewType>
-    struct replacer : std::conditional<::brigand::apply<Pred, T>::value, NewType, T>
+    struct replacer : std::conditional<rep_helper<Pred, T>::type::value, NewType, T>
     {
     };
     template <typename T, template <typename...> class F, typename NewType>
@@ -35,7 +41,7 @@ namespace lazy
 
     template <typename Sequence, typename Predicate, typename NewType>
     struct replace_if;
-    //#ifdef BRIGAND_COMP_MSVC
+
     template <template <typename...> class S, typename... Ts, typename Predicate, typename NewType>
     struct replace_if<S<Ts...>, Predicate, NewType>
     {
diff --git a/brigand/algorithms/sort.hpp b/brigand/algorithms/sort.hpp
index 2c279e3..ec6a088 100644
--- a/brigand/algorithms/sort.hpp
+++ b/brigand/algorithms/sort.hpp
@@ -52,8 +52,8 @@ namespace detail
     template <class T0, class T1, class Comp>
     struct mini_sort<list<T0, T1>, Comp>
     {
-        using type = typename std::conditional<::brigand::apply<Comp, T0, T1>::value, list<T0, T1>,
-                                               list<T1, T0>>::type;
+        using base = ::brigand::apply<Comp, T0, T1>;
+        using type = typename std::conditional<base::value, list<T0, T1>, list<T1, T0>>::type;
     };
 
     template <class T0, class Comp>
diff --git a/brigand/algorithms/split_at.hpp b/brigand/algorithms/split_at.hpp
index 419ec11..4a69095 100644
--- a/brigand/algorithms/split_at.hpp
+++ b/brigand/algorithms/split_at.hpp
@@ -14,11 +14,21 @@ namespace detail
 {
     template <bool b, typename O, typename L, std::size_t I>
     struct split_at_impl; // if you get an error here your index is out of bounds
+
+#if defined(BRIGAND_COMP_INTEL)
     template <template <typename...> class S, typename... Os>
     struct split_at_impl<false, S<Os...>, S<>, 0>
     {
         using type = S<S<Os...>, S<> >;
     };
+#else
+    template <template <typename...> class S, typename... Os, typename... Ts>
+    struct split_at_impl<false, S<Os...>, S<Ts...>, 0>
+    {
+        using type = S<S<Os...>, S<Ts...>>;
+    };
+#endif
+
     template <template <typename...> class S, typename... Os, typename T, typename... Ts>
     struct split_at_impl<false, S<Os...>, S<T, Ts...>, 0>
     {
@@ -55,4 +65,4 @@ namespace lazy
 }
 template <typename L, typename I>
 using split_at = typename ::brigand::lazy::split_at<L, I>::type;
-}
\ No newline at end of file
+}
diff --git a/brigand/algorithms/transform.hpp b/brigand/algorithms/transform.hpp
index 090d736..4e9701f 100644
--- a/brigand/algorithms/transform.hpp
+++ b/brigand/algorithms/transform.hpp
@@ -82,20 +82,20 @@ namespace brigand
       using type = Seq<brigand::apply<Func, T>...>;
     };
 
-	//fast track for eager
-	template<template<class...> class Seq, class... T, template<typename...> class Func>
-	struct transform<0, Seq<T...>, bind<Func, _1>>
-	{
-		using type = Seq<Func<T>...>;
-	};
-
-	//fast track for lazy
-	template<template<class...> class Seq, class... T, template<typename...> class Func>
-	struct transform<0, Seq<T...>, Func<_1>>
-	{
-		using type = Seq<typename Func<T>::type...>;
-	}; 
-	  
+  //fast track for eager
+  template<template<class...> class Seq, class... T, template<typename...> class Func>
+  struct transform<0, Seq<T...>, bind<Func, _1>>
+  {
+    using type = Seq<Func<T>...>;
+  };
+
+  //fast track for lazy
+  template<template<class...> class Seq, class... T, template<typename...> class Func>
+  struct transform<0, Seq<T...>, Func<_1>>
+  {
+    using type = Seq<typename Func<T>::type...>;
+  };
+
     template<template<class...> class Seq1, class... T1, template<class...> class Seq2, class... T2, class Func>
     struct transform<1, Seq1<T1...>, Seq2<T2...>, Func>
     {
@@ -106,7 +106,7 @@ namespace brigand
   namespace lazy
   {
     template<typename Sequence1, typename OpSeq1, typename... OpSeq2>
-	struct transform : detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...> {};
+  struct transform : detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...> {};
   }
 
   // Main transform entry point
diff --git a/brigand/functions/lambda/apply.hpp b/brigand/functions/lambda/apply.hpp
index 24a5b9f..c66b39f 100644
--- a/brigand/functions/lambda/apply.hpp
+++ b/brigand/functions/lambda/apply.hpp
@@ -31,76 +31,76 @@ namespace detail
 {
 
     template <typename T, typename... Ts>
-    struct packaged_lcall		//this is used in ourder to propagate args from super lambdas to sub lambdas
+    struct packaged_lcall    //this is used in ourder to propagate args from super lambdas to sub lambdas
     {
     };
     template <typename T, typename... Ls>
-	struct apply {
-		using type = T;  //default is interpreted as if it were a pin<T>
-	};
+  struct apply {
+    using type = T;  //default is interpreted as if it were a pin<T>
+  };
 
-	//eager call case
-	template <template<typename...> class F, typename...Ts, typename... Args>
-	struct apply<bind<F,Ts...>, Args...>
-	{
-		using type = F<typename apply<Ts, Args...>::type...>;
-	};
+  //eager call case
+  template <template<typename...> class F, typename...Ts, typename... Args>
+  struct apply<bind<F,Ts...>, Args...>
+  {
+    using type = F<typename apply<Ts, Args...>::type...>;
+  };
 
-	//lazy call cases
-	template <template <typename...> class F, typename... Ts, typename L, typename... Ls>
-	struct apply<F<Ts...>, L, Ls...> : F<typename apply<Ts, L, Ls...>::type...>
-	{
-	};
+  //lazy call cases
+  template <template <typename...> class F, typename... Ts, typename L, typename... Ls>
+  struct apply<F<Ts...>, L, Ls...> : F<typename apply<Ts, L, Ls...>::type...>
+  {
+  };
 
     //pin case
-	template <typename T, typename... Args, typename...Ls>
-	struct apply<pin<T>, list<Args...>, Ls...>
-	{
-		using type = T;
-	};
-	//arg case
-	template <std::size_t N, typename L, typename...Ls>
-	struct apply<args<N>, L, Ls...>
-	{
-		using type = at_c<L, N>;
-	};
-	//arg fast track
-	template <typename T, typename...Ts, typename...Ls>
-	struct apply<_1, list<T, Ts...>, Ls...>
-	{
-		using type = T;
-	};
-	//arg fast track
-	template <typename T, typename U, typename...Ts, typename...Ls>
-	struct apply<_2, list<T, U, Ts...>, Ls...>
-	{
-		using type = U;
-	};
-	//parent case
-	template <typename T, typename L, typename...Ls>
-	struct apply<parent<T>, L, Ls...> : apply<T,Ls...>
-	{
-	};
-	//defer case
-	template <typename Lambda, typename L, typename...Ls>
-	struct apply<defer<Lambda>, L, Ls...>
-	{
-		using type = packaged_lcall<Lambda, L, Ls...>;
-	};
-	//packaged_lcall lazy case
-	template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
-	struct apply<packaged_lcall<Lambda<Ts...>, PLs...>, L, Ls...> : Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>
-	{
-	};
-	//packaged_lcall eager case
-	template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
-	struct apply<packaged_lcall<bind<Lambda,Ts...>, PLs...>, L, Ls...> 
-	{
-		using type = Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>;
-	};
+  template <typename T, typename... Args, typename...Ls>
+  struct apply<pin<T>, list<Args...>, Ls...>
+  {
+    using type = T;
+  };
+  //arg case
+  template <std::size_t N, typename L, typename...Ls>
+  struct apply<args<N>, L, Ls...>
+  {
+    using type = at_c<L, N>;
+  };
+  //arg fast track
+  template <typename T, typename...Ts, typename...Ls>
+  struct apply<_1, list<T, Ts...>, Ls...>
+  {
+    using type = T;
+  };
+  //arg fast track
+  template <typename T, typename U, typename...Ts, typename...Ls>
+  struct apply<_2, list<T, U, Ts...>, Ls...>
+  {
+    using type = U;
+  };
+  //parent case
+  template <typename T, typename L, typename...Ls>
+  struct apply<parent<T>, L, Ls...> : apply<T,Ls...>
+  {
+  };
+  //defer case
+  template <typename Lambda, typename L, typename...Ls>
+  struct apply<defer<Lambda>, L, Ls...>
+  {
+    using type = packaged_lcall<Lambda, L, Ls...>;
+  };
+  //packaged_lcall lazy case
+  template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
+  struct apply<packaged_lcall<Lambda<Ts...>, PLs...>, L, Ls...> : Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>
+  {
+  };
+  //packaged_lcall eager case
+  template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
+  struct apply<packaged_lcall<bind<Lambda,Ts...>, PLs...>, L, Ls...>
+  {
+    using type = Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>;
+  };
 
-	template<typename T, typename...Ts>
-	using bound_apply = typename apply<T, brigand::list<Ts...>>::type;
+  template<typename T, typename...Ts>
+  using bound_apply = typename apply<T, brigand::list<Ts...>>::type;
 
 }
 
diff --git a/brigand/functions/lambda/bind.hpp b/brigand/functions/lambda/bind.hpp
index 00177f4..acfb9ab 100644
--- a/brigand/functions/lambda/bind.hpp
+++ b/brigand/functions/lambda/bind.hpp
@@ -10,8 +10,8 @@
 
 namespace brigand
 {
-	template <template <typename...> class, typename...>
-	struct bind
-	{
-	};
+  template <template <typename...> class, typename...>
+  struct bind
+  {
+  };
 }
diff --git a/brigand/sequences/append.hpp b/brigand/sequences/append.hpp
index a4ac3eb..6a55e7f 100644
--- a/brigand/sequences/append.hpp
+++ b/brigand/sequences/append.hpp
@@ -55,8 +55,8 @@ namespace detail
 }
 namespace lazy
 {
-	template <typename... Ts>
-	using append = detail::append_impl<Ts...>;
+  template <typename... Ts>
+  using append = detail::append_impl<Ts...>;
 }
 template <typename... Ts>
 using append = typename detail::append_impl<Ts...>::type;
@@ -64,12 +64,12 @@ using append = typename detail::append_impl<Ts...>::type;
 
 namespace lazy
 {
-	template <typename T>
-	struct join;
-	template<template<typename...> class L, typename...Ts>
-	struct join<L<Ts...>> : ::brigand::detail::append_impl<L<>,Ts...>
-	{
-	};
+  template <typename T>
+  struct join;
+  template<template<typename...> class L, typename...Ts>
+  struct join<L<Ts...>> : ::brigand::detail::append_impl<L<>,Ts...>
+  {
+  };
 }
 template <typename T>
 using join = wrap<T,append>;
diff --git a/brigand/sequences/front.hpp b/brigand/sequences/front.hpp
index 7c7b1dc..679031a 100644
--- a/brigand/sequences/front.hpp
+++ b/brigand/sequences/front.hpp
@@ -23,8 +23,8 @@ namespace brigand
   }
 
   namespace lazy {
-	  template<class L, class... T>
-	  struct push_front : detail::push_front_impl<L, T...>{};
+    template<class L, class... T>
+    struct push_front : detail::push_front_impl<L, T...>{};
   }
 
   template<class L, class... T>
@@ -74,8 +74,8 @@ namespace brigand
     };
   }
   namespace lazy {
-	  template <class L, class N = std::integral_constant<std::size_t, 1>>
-	  struct pop_front : detail::pop_front_impl<L, N::value> {};
+    template <class L, class N = std::integral_constant<std::size_t, 1>>
+    struct pop_front : detail::pop_front_impl<L, N::value> {};
   }
   template <class L, class N = std::integral_constant<std::size_t, 1>>
   using pop_front = typename detail::pop_front_impl<L, N::value>::type;
diff --git a/brigand/sequences/keys_as_sequence.hpp b/brigand/sequences/keys_as_sequence.hpp
index c5c7efc..a4fd112 100644
--- a/brigand/sequences/keys_as_sequence.hpp
+++ b/brigand/sequences/keys_as_sequence.hpp
@@ -9,9 +9,9 @@ namespace brigand
 namespace detail
 {
     template <typename Pair>
-	struct get_first {
-		using type = typename Pair::first_type;
-	};
+  struct get_first {
+    using type = typename Pair::first_type;
+  };
 } // namespace detail
 
 template <typename Map, template <class...> class Sequence = brigand::set>
diff --git a/brigand/sequences/map.hpp b/brigand/sequences/map.hpp
index 7c0ca7b..7bf8a42 100644
--- a/brigand/sequences/map.hpp
+++ b/brigand/sequences/map.hpp
@@ -18,8 +18,14 @@ namespace brigand
 namespace lazy
 {
     template <typename M, typename K>
-    struct lookup
-    : decltype(M::at(type_<K>{}))
+    struct lookup_at
+    {
+      using target_t = type_<K>;
+      using type     = decltype(M::at(target_t{}));
+    };
+
+    template <typename M, typename K>
+    struct lookup : lookup_at<M,K>::type
     {};
 }
 
@@ -69,8 +75,16 @@ namespace detail
         template <class K>
         static std::false_type has_key(K);
 
+        template <class K, class X>
+        using erase_t = typename std::conditional < std::is_same<K, typename X::first_type>::value
+                                                  , list<>, list<X>
+                                                  >::type;
+
+        template <class K, typename... Xs>
+        struct erase_return_t  { using type = append< map_impl<>, erase_t<K,Xs>... >; };
+
         template <class K>
-        static append<map_impl<>, typename std::conditional<std::is_same<K, typename Ts::first_type>::value, list<>, list<Ts>>::type...> erase(type_<K>);
+        static typename erase_return_t<K,Ts...>::type erase(type_<K>);
 
         template <class P, class = decltype(static_cast<pair<typename P::first_type, P>*>(static_cast<Pack*>(nullptr)))>
         static map_impl insert(type_<P>);
diff --git a/brigand/sequences/values_as_sequence.hpp b/brigand/sequences/values_as_sequence.hpp
index cc5d4f9..19b3fca 100644
--- a/brigand/sequences/values_as_sequence.hpp
+++ b/brigand/sequences/values_as_sequence.hpp
@@ -8,9 +8,9 @@ namespace brigand
 namespace detail
 {
     template <typename Pair>
-	struct get_second {
-		using type = typename Pair::second_type;
-	};
+  struct get_second {
+    using type = typename Pair::second_type;
+  };
 } // namespace detail
 
 template <typename Map, template <class...> class Sequence = brigand::list>
diff --git a/brigand/types/inherit_linearly.hpp b/brigand/types/inherit_linearly.hpp
index c988fe8..c3f35c8 100644
--- a/brigand/types/inherit_linearly.hpp
+++ b/brigand/types/inherit_linearly.hpp
@@ -13,16 +13,16 @@ namespace brigand
 {
   namespace lazy
   {
-	  template< typename Types
-		  , typename Node
-		  , typename Root = brigand::empty_base
-	  >
-		  struct inherit_linearly;
-	template< typename Types
-		  , template<typename...> class Node, typename...Ts
-		  , typename Root
-	  >
-	struct inherit_linearly<Types,Node<Ts...>,Root>
+    template< typename Types
+      , typename Node
+      , typename Root = brigand::empty_base
+    >
+      struct inherit_linearly;
+  template< typename Types
+      , template<typename...> class Node, typename...Ts
+      , typename Root
+    >
+  struct inherit_linearly<Types,Node<Ts...>,Root>
     {
       // TODO: change after lazy-fication
       using type = brigand::fold<Types,Root,bind<Node,Ts...>>;
diff --git a/standalone/brigand.hpp b/standalone/brigand.hpp
index 8dc43d0..5d98110 100644
--- a/standalone/brigand.hpp
+++ b/standalone/brigand.hpp
@@ -71,19 +71,19 @@ namespace detail
 }
 namespace lazy
 {
-	template <typename... Ts>
-	using append = detail::append_impl<Ts...>;
+  template <typename... Ts>
+  using append = detail::append_impl<Ts...>;
 }
 template <typename... Ts>
 using append = typename detail::append_impl<Ts...>::type;
 namespace lazy
 {
-	template <typename T>
-	struct join;
-	template<template<typename...> class L, typename...Ts>
-	struct join<L<Ts...>> : ::brigand::detail::append_impl<L<>,Ts...>
-	{
-	};
+  template <typename T>
+  struct join;
+  template<template<typename...> class L, typename...Ts>
+  struct join<L<Ts...>> : ::brigand::detail::append_impl<L<>,Ts...>
+  {
+  };
 }
 template <typename T>
 using join = wrap<T,append>;
@@ -111,8 +111,13 @@ namespace brigand
 namespace lazy
 {
     template <typename M, typename K>
-    struct lookup
-    : decltype(M::at(type_<K>{}))
+    struct lookup_at
+    {
+      using target_t = type_<K>;
+      using type     = decltype(M::at(target_t{}));
+    };
+    template <typename M, typename K>
+    struct lookup : lookup_at<M,K>::type
     {};
 }
     template <typename M, typename K>
@@ -149,8 +154,14 @@ namespace detail
         static std::true_type has_key(type_<K>);
         template <class K>
         static std::false_type has_key(K);
+        template <class K, class X>
+        using erase_t = typename std::conditional < std::is_same<K, typename X::first_type>::value
+                                                  , list<>, list<X>
+                                                  >::type;
+        template <class K, typename... Xs>
+        struct erase_return_t  { using type = append< map_impl<>, erase_t<K,Xs>... >; };
         template <class K>
-        static append<map_impl<>, typename std::conditional<std::is_same<K, typename Ts::first_type>::value, list<>, list<Ts>>::type...> erase(type_<K>);
+        static typename erase_return_t<K,Ts...>::type erase(type_<K>);
         template <class P, class = decltype(static_cast<pair<typename P::first_type, P>*>(static_cast<Pack*>(nullptr)))>
         static map_impl insert(type_<P>);
         template <class P>
@@ -243,10 +254,10 @@ namespace detail
 }
 namespace brigand
 {
-	template <template <typename...> class, typename...>
-	struct bind
-	{
-	};
+  template <template <typename...> class, typename...>
+  struct bind
+  {
+  };
 }
 namespace brigand
 {
@@ -286,58 +297,58 @@ namespace detail
     {
     };
     template <typename T, typename... Ls>
-	struct apply {
-		using type = T;
-	};
-	template <template<typename...> class F, typename...Ts, typename... Args>
-	struct apply<bind<F,Ts...>, Args...>
-	{
-		using type = F<typename apply<Ts, Args...>::type...>;
-	};
-	template <template <typename...> class F, typename... Ts, typename L, typename... Ls>
-	struct apply<F<Ts...>, L, Ls...> : F<typename apply<Ts, L, Ls...>::type...>
-	{
-	};
-	template <typename T, typename... Args, typename...Ls>
-	struct apply<pin<T>, list<Args...>, Ls...>
-	{
-		using type = T;
-	};
-	template <std::size_t N, typename L, typename...Ls>
-	struct apply<args<N>, L, Ls...>
-	{
-		using type = at_c<L, N>;
-	};
-	template <typename T, typename...Ts, typename...Ls>
-	struct apply<_1, list<T, Ts...>, Ls...>
-	{
-		using type = T;
-	};
-	template <typename T, typename U, typename...Ts, typename...Ls>
-	struct apply<_2, list<T, U, Ts...>, Ls...>
-	{
-		using type = U;
-	};
-	template <typename T, typename L, typename...Ls>
-	struct apply<parent<T>, L, Ls...> : apply<T,Ls...>
-	{
-	};
-	template <typename Lambda, typename L, typename...Ls>
-	struct apply<defer<Lambda>, L, Ls...>
-	{
-		using type = packaged_lcall<Lambda, L, Ls...>;
-	};
-	template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
-	struct apply<packaged_lcall<Lambda<Ts...>, PLs...>, L, Ls...> : Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>
-	{
-	};
-	template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
-	struct apply<packaged_lcall<bind<Lambda,Ts...>, PLs...>, L, Ls...> 
-	{
-		using type = Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>;
-	};
-	template<typename T, typename...Ts>
-	using bound_apply = typename apply<T, brigand::list<Ts...>>::type;
+  struct apply {
+    using type = T;
+  };
+  template <template<typename...> class F, typename...Ts, typename... Args>
+  struct apply<bind<F,Ts...>, Args...>
+  {
+    using type = F<typename apply<Ts, Args...>::type...>;
+  };
+  template <template <typename...> class F, typename... Ts, typename L, typename... Ls>
+  struct apply<F<Ts...>, L, Ls...> : F<typename apply<Ts, L, Ls...>::type...>
+  {
+  };
+  template <typename T, typename... Args, typename...Ls>
+  struct apply<pin<T>, list<Args...>, Ls...>
+  {
+    using type = T;
+  };
+  template <std::size_t N, typename L, typename...Ls>
+  struct apply<args<N>, L, Ls...>
+  {
+    using type = at_c<L, N>;
+  };
+  template <typename T, typename...Ts, typename...Ls>
+  struct apply<_1, list<T, Ts...>, Ls...>
+  {
+    using type = T;
+  };
+  template <typename T, typename U, typename...Ts, typename...Ls>
+  struct apply<_2, list<T, U, Ts...>, Ls...>
+  {
+    using type = U;
+  };
+  template <typename T, typename L, typename...Ls>
+  struct apply<parent<T>, L, Ls...> : apply<T,Ls...>
+  {
+  };
+  template <typename Lambda, typename L, typename...Ls>
+  struct apply<defer<Lambda>, L, Ls...>
+  {
+    using type = packaged_lcall<Lambda, L, Ls...>;
+  };
+  template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
+  struct apply<packaged_lcall<Lambda<Ts...>, PLs...>, L, Ls...> : Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>
+  {
+  };
+  template <template <typename...> class Lambda, typename... Ts, typename... PLs, typename L, typename...Ls>
+  struct apply<packaged_lcall<bind<Lambda,Ts...>, PLs...>, L, Ls...>
+  {
+    using type = Lambda<typename apply<Ts, L, Ls..., PLs...>::type...>;
+  };
+  template<typename T, typename...Ts>
+  using bound_apply = typename apply<T, brigand::list<Ts...>>::type;
 }
 template <typename Lambda, typename... Args>
 using apply = typename detail::apply<Lambda, brigand::list<Args...>>::type;
@@ -416,11 +427,13 @@ namespace brigand
 {
 namespace detail
 {
+#if defined(BRIGAND_COMP_GCC) || defined(BRIGAND_COMP_CLANG)
     constexpr std::size_t count_bools(bool const * const begin, bool const * const end,
                                       std::size_t n)
     {
         return begin == end ? n : detail::count_bools(begin + 1, end, n + *begin);
     }
+#endif
     template <bool... Bs>
     struct template_count_bools
     {
@@ -467,27 +480,37 @@ namespace lazy
     struct count_if<S<Ts...>, Pred>
     {
         static constexpr bool s_v[] = {::brigand::apply<Pred, Ts>::type::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
     };
     template <template <typename...> class S, typename... Ts, template <typename...> class F>
     struct count_if<S<Ts...>, bind<F, _1>>
     {
         static constexpr bool s_v[] = {F<Ts>::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
     };
     template <template <typename...> class S, typename... Ts, template <typename...> class F>
     struct count_if<S<Ts...>, F<_1>>
     {
         static constexpr bool s_v[] = {F<Ts>::type::value...};
-        using type = brigand::size_t<::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+        using type = brigand::size_t< ::brigand::detail::count_bools(s_v, s_v + sizeof...(Ts), 0u)>;
+    };
+#else
+#if defined(BRIGAND_COMP_MSVC_2015)
+    template <template <typename...> class S, typename... Ts, typename Pred>
+    struct count_if<S<Ts...>, Pred>
+        : ::brigand::detail::template_count_bools< ::brigand::apply<Pred, Ts>::value...>
+    {
     };
 #else
     template <template <typename...> class S, typename... Ts, typename Pred>
     struct count_if<S<Ts...>, Pred>
-        : ::brigand::detail::template_count_bools<::brigand::apply<Pred, Ts>::value...>
     {
+        template <typename T>
+        using val_t = brigand::apply<Pred, T>;
+        using type = typename ::brigand::detail::template_count_bools<val_t<Ts>::value...>::type;
     };
 #endif
+#endif
 }
 template <typename List, typename Pred>
 using count_if = typename lazy::count_if<List, Pred>::type;
@@ -510,8 +533,8 @@ namespace brigand
     };
   }
   namespace lazy {
-	  template<class L, class... T>
-	  struct push_front : detail::push_front_impl<L, T...>{};
+    template<class L, class... T>
+    struct push_front : detail::push_front_impl<L, T...>{};
   }
   template<class L, class... T>
   using push_front = typename detail::push_front_impl<L, T...>::type;
@@ -550,8 +573,8 @@ namespace brigand
     };
   }
   namespace lazy {
-	  template <class L, class N = std::integral_constant<std::size_t, 1>>
-	  struct pop_front : detail::pop_front_impl<L, N::value> {};
+    template <class L, class N = std::integral_constant<std::size_t, 1>>
+    struct pop_front : detail::pop_front_impl<L, N::value> {};
   }
   template <class L, class N = std::integral_constant<std::size_t, 1>>
   using pop_front = typename detail::pop_front_impl<L, N::value>::type;
@@ -578,11 +601,19 @@ namespace detail
 {
     template <bool b, typename O, typename L, std::size_t I>
     struct split_at_impl;
+#if defined(BRIGAND_COMP_INTEL)
     template <template <typename...> class S, typename... Os>
     struct split_at_impl<false, S<Os...>, S<>, 0>
     {
         using type = S<S<Os...>, S<> >;
     };
+#else
+    template <template <typename...> class S, typename... Os, typename... Ts>
+    struct split_at_impl<false, S<Os...>, S<Ts...>, 0>
+    {
+        using type = S<S<Os...>, S<Ts...>>;
+    };
+#endif
     template <template <typename...> class S, typename... Os, typename T, typename... Ts>
     struct split_at_impl<false, S<Os...>, S<T, Ts...>, 0>
     {
@@ -696,16 +727,16 @@ namespace brigand
     {
       using type = Seq<brigand::apply<Func, T>...>;
     };
-	template<template<class...> class Seq, class... T, template<typename...> class Func>
-	struct transform<0, Seq<T...>, bind<Func, _1>>
-	{
-		using type = Seq<Func<T>...>;
-	};
-	template<template<class...> class Seq, class... T, template<typename...> class Func>
-	struct transform<0, Seq<T...>, Func<_1>>
-	{
-		using type = Seq<typename Func<T>::type...>;
-	}; 
+  template<template<class...> class Seq, class... T, template<typename...> class Func>
+  struct transform<0, Seq<T...>, bind<Func, _1>>
+  {
+    using type = Seq<Func<T>...>;
+  };
+  template<template<class...> class Seq, class... T, template<typename...> class Func>
+  struct transform<0, Seq<T...>, Func<_1>>
+  {
+    using type = Seq<typename Func<T>::type...>;
+  };
     template<template<class...> class Seq1, class... T1, template<class...> class Seq2, class... T2, class Func>
     struct transform<1, Seq1<T1...>, Seq2<T2...>, Func>
     {
@@ -715,7 +746,7 @@ namespace brigand
   namespace lazy
   {
     template<typename Sequence1, typename OpSeq1, typename... OpSeq2>
-	struct transform : detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...> {};
+  struct transform : detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...> {};
   }
   template<typename Sequence1, typename OpSeq1, typename... OpSeq2>
   using transform = typename detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...>::type;
@@ -811,7 +842,7 @@ namespace brigand
 namespace detail
 {
     template <typename Args>
-	struct non_null_impl : bool_<Args::value != 0>{};
+  struct non_null_impl : bool_<Args::value != 0>{};
     using non_null = non_null_impl<_1>;
 }
 }
@@ -822,6 +853,10 @@ namespace brigand
 #if defined(BRIGAND_COMP_MSVC_2013) || defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL)
 namespace detail
 {
+    template <class P, class T>
+    struct all_helper : ::brigand::apply<P, T>
+    {
+    };
     template <bool...>
     struct bools_
     {
@@ -830,8 +865,8 @@ namespace detail
     struct all_impl;
     template <template <class...> class Sequence, typename Predicate, typename... Ts>
     struct all_impl<Sequence<Ts...>, Predicate>
-        : std::is_same<bools_<true, ::brigand::apply<Predicate, Ts>::value...>,
-                       bools_<::brigand::apply<Predicate, Ts>::value..., true>>
+        : std::is_same<bools_<true, all_helper<Predicate, Ts>::value...>,
+                       bools_<all_helper<Predicate, Ts>::value..., true>>
     {
     };
 }
@@ -855,8 +890,8 @@ namespace detail
     struct all_impl<Sequence<T, Ts...>, Predicate>
     {
         static constexpr all_same tester{
-            static_cast<::brigand::apply<Predicate, T> *>(nullptr),
-            static_cast<::brigand::apply<Predicate, Ts> *>(nullptr)...};
+            static_cast< ::brigand::apply<Predicate, T> *>(nullptr),
+            static_cast< ::brigand::apply<Predicate, Ts> *>(nullptr)...};
         using type = bool_<(::brigand::apply<Predicate, T>::value != 0 && tester.value)>;
     };
     template <template <class...> class Sequence, template <typename...> class F, typename T,
@@ -908,8 +943,8 @@ namespace detail
     struct none_impl<Sequence<T, Ts...>, Predicate>
     {
         static constexpr all_same tester{
-            static_cast<::brigand::apply<Predicate, T> *>(nullptr),
-            static_cast<::brigand::apply<Predicate, Ts> *>(nullptr)...};
+            static_cast< ::brigand::apply<Predicate, T> *>(nullptr),
+            static_cast< ::brigand::apply<Predicate, Ts> *>(nullptr)...};
         using type = bool_<(::brigand::apply<Predicate, T>::value == 0 && tester.value)>;
     };
     template <template <class...> class Sequence, template <typename...> class F, typename T,
@@ -1054,7 +1089,7 @@ namespace lazy
 {
     template <typename Sequence, typename Predicate = detail::non_null>
     using reverse_find =
-        ::brigand::lazy::reverse<::brigand::find<brigand::reverse<Sequence>, Predicate>>;
+        ::brigand::lazy::reverse< ::brigand::find<brigand::reverse<Sequence>, Predicate>>;
 }
 template <typename Sequence, typename Predicate = detail::non_null>
 using reverse_find = typename ::brigand::lazy::reverse_find<Sequence, Predicate>::type;
@@ -1330,7 +1365,7 @@ namespace detail
     struct index_if_impl
     {
         using type = ::brigand::size_t<size<Sequence>::value -
-                                       size<::brigand::find<Sequence, Predicate>>::value>;
+                                       size< ::brigand::find<Sequence, Predicate>>::value>;
     };
     template <class Sequence, typename Predicate, typename NotFoundType>
     struct index_if_impl<false, Sequence, Predicate, NotFoundType>
@@ -1339,7 +1374,7 @@ namespace detail
     };
 }
 template <class Sequence, class Predicate, class NotFoundType = no_such_type_>
-using index_if = typename detail::index_if_impl<::brigand::found<Sequence, Predicate>::value,
+using index_if = typename detail::index_if_impl< ::brigand::found<Sequence, Predicate>::value,
                                                 Sequence, Predicate, NotFoundType>::type;
 template <class Sequence, typename T>
 using index_of = index_if<Sequence, std::is_same<T, ::brigand::_1>>;
@@ -1509,7 +1544,7 @@ namespace lazy
     template <template <class...> class L, typename... Ts, typename Pred>
     struct remove_if<L<Ts...>, Pred>
         : ::brigand::detail::append_impl<
-              L<>, typename std::conditional<::brigand::apply<Pred, Ts>::value, list<>,
+              L<>, typename std::conditional< ::brigand::apply<Pred, Ts>::value, list<>,
                                              list<Ts>>::type...>
     {
     };
@@ -1544,7 +1579,7 @@ namespace lazy
     template <template <class...> class L, typename... Ts, typename Pred>
     struct filter<L<Ts...>, Pred>
         : ::brigand::detail::append_impl<
-              L<>, typename std::conditional<::brigand::apply<Pred, Ts>::value, list<Ts>,
+              L<>, typename std::conditional< ::brigand::apply<Pred, Ts>::value, list<Ts>,
                                              list<>>::type...>
     {
     };
@@ -1564,8 +1599,12 @@ namespace lazy
 #else
 namespace detail
 {
+    template <class Pred, class T>
+    struct empty_helper : ::brigand::apply<Pred, T>
+    {
+    };
     template <typename Pred, typename T, bool B>
-    struct empty_if_true : std::conditional<::brigand::apply<Pred, T>::value == B, list<>, list<T>>
+    struct empty_if_true : std::conditional<empty_helper<Pred, T>::value == B, list<>, list<T>>
     {
     };
     template <template <typename...> class F, typename T, bool B>
@@ -1628,8 +1667,13 @@ namespace brigand
 {
 namespace detail
 {
+    template <typename Pred, typename T>
+    struct rep_helper
+    {
+        using type = brigand::apply<Pred, T>;
+    };
     template <typename T, typename Pred, typename NewType>
-    struct replacer : std::conditional<::brigand::apply<Pred, T>::value, NewType, T>
+    struct replacer : std::conditional<rep_helper<Pred, T>::type::value, NewType, T>
     {
     };
     template <typename T, template <typename...> class F, typename NewType>
@@ -1731,13 +1775,17 @@ namespace brigand
 {
 namespace detail
 {
+    template <class Comp, class T1, class U>
+    struct merge_helper : ::brigand::apply<Comp, T1, U>
+    {
+    };
     template <class L, class Seq1, class Seq2, class Comp>
     struct merge_impl;
     template <bool, class L, class Seq1, class Seq2, class Comp>
     struct merge_insert;
     template <class... R, class T0, class T1, class... Ts, class U, class... Us, class Comp>
     struct merge_insert<true, list<R...>, list<T0, T1, Ts...>, list<U, Us...>, Comp>
-        : merge_insert<::brigand::apply<Comp, T1, U>::value, list<R..., T0>, list<T1, Ts...>,
+        : merge_insert<merge_helper<Comp, T1, U>::value, list<R..., T0>, list<T1, Ts...>,
                        list<U, Us...>, Comp>
     {
     };
@@ -1750,7 +1798,7 @@ namespace detail
     };
     template <class... R, class T, class... Ts, class U0, class U1, class... Us, class Comp>
     struct merge_insert<false, list<R...>, list<T, Ts...>, list<U0, U1, Us...>, Comp>
-        : merge_insert<::brigand::apply<Comp, T, U1>::value, list<R..., U0>, list<T, Ts...>,
+        : merge_insert<merge_helper<Comp, T, U1>::value, list<R..., U0>, list<T, Ts...>,
                        list<U1, Us...>, Comp>
     {
     };
@@ -1767,7 +1815,7 @@ namespace detail
     struct merge_impl<list<R...>, list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>,
                       list<U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, Us...>, Comp>
     {
-        using sub = merge_insert<::brigand::apply<Comp, T0, U0>::value, list<>,
+        using sub = merge_insert<merge_helper<Comp, T0, U0>::value, list<>,
                                  list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
                                  list<U0, U1, U2, U3, U4, U5, U6, U7, U8, U9>, Comp>;
         using type = typename merge_impl<append<list<R...>, typename sub::list>,
@@ -1776,7 +1824,7 @@ namespace detail
     };
     template <class... R, class T, class... Ts, class U, class... Us, class Comp>
     struct merge_impl<list<R...>, list<T, Ts...>, list<U, Us...>, Comp>
-        : std::conditional<::brigand::apply<Comp, T, U>::value,
+        : std::conditional<merge_helper<Comp, T, U>::value,
                            merge_impl<list<R..., T>, list<Ts...>, list<U, Us...>, Comp>,
                            merge_impl<list<R..., U>, list<T, Ts...>, list<Us...>, Comp>>::type
     {
@@ -1837,8 +1885,8 @@ namespace detail
     template <class T0, class T1, class Comp>
     struct mini_sort<list<T0, T1>, Comp>
     {
-        using type = typename std::conditional<::brigand::apply<Comp, T0, T1>::value, list<T0, T1>,
-                                               list<T1, T0>>::type;
+        using base = ::brigand::apply<Comp, T0, T1>;
+        using type = typename std::conditional<base::value, list<T0, T1>, list<T1, T0>>::type;
     };
     template <class T0, class Comp>
     struct mini_sort<list<T0>, Comp>
@@ -2449,9 +2497,9 @@ namespace brigand
 namespace detail
 {
     template <typename Pair>
-	struct get_second {
-		using type = typename Pair::second_type;
-	};
+  struct get_second {
+    using type = typename Pair::second_type;
+  };
 }
 template <typename Map, template <class...> class Sequence = brigand::list>
 using values_as_sequence = transform<as_sequence<Map, Sequence>, detail::get_second<_1>>;
@@ -2461,9 +2509,9 @@ namespace brigand
 namespace detail
 {
     template <typename Pair>
-	struct get_first {
-		using type = typename Pair::first_type;
-	};
+  struct get_first {
+    using type = typename Pair::first_type;
+  };
 }
 template <typename Map, template <class...> class Sequence = brigand::set>
 using keys_as_sequence = transform<as_sequence<Map, Sequence>, detail::get_first<_1>>;
@@ -2519,16 +2567,16 @@ namespace brigand
 {
   namespace lazy
   {
-	  template< typename Types
-		  , typename Node
-		  , typename Root = brigand::empty_base
-	  >
-		  struct inherit_linearly;
-	template< typename Types
-		  , template<typename...> class Node, typename...Ts
-		  , typename Root
-	  >
-	struct inherit_linearly<Types,Node<Ts...>,Root>
+    template< typename Types
+      , typename Node
+      , typename Root = brigand::empty_base
+    >
+      struct inherit_linearly;
+  template< typename Types
+      , template<typename...> class Node, typename...Ts
+      , typename Root
+    >
+  struct inherit_linearly<Types,Node<Ts...>,Root>
     {
       using type = brigand::fold<Types,Root,bind<Node,Ts...>>;
     };
diff --git a/test/apply.cpp b/test/apply.cpp
index b7f97d3..cdf216e 100644
--- a/test/apply.cpp
+++ b/test/apply.cpp
@@ -8,7 +8,7 @@ static_assert(brigand::apply<std::is_same<brigand::_1, int>, float>::value == fa
 static_assert(brigand::apply<std::is_same<int, brigand::_1>, int>::value == true, "invalid apply2 result");
 
 static_assert (brigand::apply < std::is_same<brigand::_5, brigand::_1>
-	, float, void, void, void, float
+  , float, void, void, void, float
 >::value == true
 , "invalid apply3 result"
 );
@@ -16,7 +16,7 @@ static_assert (brigand::apply < std::is_same<brigand::_5, brigand::_1>
 template<typename T>
 struct is_int
 {
-	using type = typename std::is_same<T, int>::type;
+  using type = typename std::is_same<T, int>::type;
 };
 
 static_assert(brigand::apply<is_int<brigand::_1>, float>::value == false, "invalid apply1 result");
diff --git a/test/bind.cpp b/test/bind.cpp
index 12f5cbf..1eb7a9e 100644
--- a/test/bind.cpp
+++ b/test/bind.cpp
@@ -10,13 +10,13 @@ using f5 = T5;
 
 
 static_assert (std::is_same < brigand::apply< brigand::bind<f1, brigand::_1>, int>
-	, int
+  , int
 >::value
 , "Invalid bind result"
 );
 
 static_assert (std::is_same < brigand::apply < brigand::bind<f1, brigand::_5>
-	, void, void, void, void, int
+  , void, void, void, void, int
 >
 , int
 >::value
@@ -24,25 +24,25 @@ static_assert (std::is_same < brigand::apply < brigand::bind<f1, brigand::_5>
 );
 
 static_assert (std::is_same
-	< brigand::apply< brigand::bind<f5, brigand::_1, brigand::_2
-	, brigand::_3, brigand::_4
-	, brigand::_5
-	>
-	, void, void, void, void, int
-	>
-	, int
-	>::value
-	, "Invalid bind result"
-	);
+  < brigand::apply< brigand::bind<f5, brigand::_1, brigand::_2
+  , brigand::_3, brigand::_4
+  , brigand::_5
+  >
+  , void, void, void, void, int
+  >
+  , int
+  >::value
+  , "Invalid bind result"
+  );
 
 static_assert (std::is_same
-	< brigand::apply< brigand::bind<f5, brigand::_5, brigand::_3
-	, brigand::_4, brigand::_2
-	, brigand::_1
-	>
-	, int, void, void, void, void
-	>
-	, int
-	>::value
-	, "Invalid bind result"
-	);
+  < brigand::apply< brigand::bind<f5, brigand::_5, brigand::_3
+  , brigand::_4, brigand::_2
+  , brigand::_1
+  >
+  , int, void, void, void, void
+  >
+  , int
+  >::value
+  , "Invalid bind result"
+  );
diff --git a/test/count_test.cpp b/test/count_test.cpp
index d34038c..7b6eb36 100644
--- a/test/count_test.cpp
+++ b/test/count_test.cpp
@@ -11,7 +11,7 @@ using is_odd = brigand::bool_<(N::value % 2) != 0>;
 
 template <typename N>
 struct lazy_is_odd {
-	using type = brigand::bool_<(N::value % 2) != 0>;
+  using type = brigand::bool_<(N::value % 2) != 0>;
 };
 
 template <std::size_t... List>
@@ -28,4 +28,4 @@ static_assert(brigand::count_if<brigand::list<>, lazy_is_odd<brigand::_1>>::valu
 static_assert(brigand::count_if<size_t_list<3>, lazy_is_odd<brigand::_1>>::value == 1, "eager single count_if error");
 static_assert(brigand::count_if<size_t_list<3>, lazy_is_odd<brigand::_1>>::value == 1, "lazy single count_if error");
 static_assert(brigand::count_if<size_t_list<2>, lazy_is_odd<brigand::_1>>::value == 0, "eager single count_if error");
-static_assert(brigand::count_if<size_t_list<2>, lazy_is_odd<brigand::_1>>::value == 0, "lazy single count_if error");
\ No newline at end of file
+static_assert(brigand::count_if<size_t_list<2>, lazy_is_odd<brigand::_1>>::value == 0, "lazy single count_if error");
diff --git a/test/partition_test.cpp b/test/partition_test.cpp
index a1cbd93..9bb100e 100644
--- a/test/partition_test.cpp
+++ b/test/partition_test.cpp
@@ -30,27 +30,27 @@ partition_test5 = brigand::pair<brigand::list<float, double>, brigand::list<int,
 // custom list tests
 namespace custom
 {
-	template <class...>
-	class custom_list
-	{
-	};
-	template <std::size_t... List>
-	using size_t_list = brigand::wrap<brigand::integral_list<std::size_t, List...>, custom_list>;
-
-	using odd_list = size_t_list<1, 3, 5, 7, 9, 11>;
-	using even_list = size_t_list<0, 2, 4, 6, 8, 10>;
-	using full_list = size_t_list<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11>;
-
-	brigand::partition<odd_list, brigand::bind<is_odd, brigand::_1>> partition_test1 =
-		brigand::pair<odd_list, size_t_list<>>{};
-	brigand::partition<even_list, brigand::bind<is_odd, brigand::_1>> partition_test2 =
-		brigand::pair<size_t_list<>, even_list>{};
-	brigand::partition<full_list, brigand::bind<is_odd, brigand::_1>> partition_test3 =
-		brigand::pair<odd_list, even_list>{};
-
-	brigand::partition<size_t_list<>, brigand::bind<is_odd, brigand::_1>> partition_test4 =
-		brigand::pair<size_t_list<>, size_t_list<>>{};
-
-	brigand::partition<brigand::list<int, float, char, double>, std::is_floating_point<brigand::_1>>
-		partition_test5 = brigand::pair<brigand::list<float, double>, brigand::list<int, char>>{};
-}
\ No newline at end of file
+  template <class...>
+  class custom_list
+  {
+  };
+  template <std::size_t... List>
+  using size_t_list = brigand::wrap<brigand::integral_list<std::size_t, List...>, custom_list>;
+
+  using odd_list = size_t_list<1, 3, 5, 7, 9, 11>;
+  using even_list = size_t_list<0, 2, 4, 6, 8, 10>;
+  using full_list = size_t_list<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11>;
+
+  brigand::partition<odd_list, brigand::bind<is_odd, brigand::_1>> partition_test1 =
+    brigand::pair<odd_list, size_t_list<>>{};
+  brigand::partition<even_list, brigand::bind<is_odd, brigand::_1>> partition_test2 =
+    brigand::pair<size_t_list<>, even_list>{};
+  brigand::partition<full_list, brigand::bind<is_odd, brigand::_1>> partition_test3 =
+    brigand::pair<odd_list, even_list>{};
+
+  brigand::partition<size_t_list<>, brigand::bind<is_odd, brigand::_1>> partition_test4 =
+    brigand::pair<size_t_list<>, size_t_list<>>{};
+
+  brigand::partition<brigand::list<int, float, char, double>, std::is_floating_point<brigand::_1>>
+    partition_test5 = brigand::pair<brigand::list<float, double>, brigand::list<int, char>>{};
+}
diff --git a/test/predicate_reduction_test.cpp b/test/predicate_reduction_test.cpp
index b2f9b46..7581639 100644
--- a/test/predicate_reduction_test.cpp
+++ b/test/predicate_reduction_test.cpp
@@ -8,20 +8,20 @@
 static_assert(brigand::none<brigand::empty_sequence>::value, "invalid none on empty list");
 
 static_assert(brigand::none<brigand::integral_list<int, 0, 0, 0, 0, 0, 0>>::value,
-	"invalid none on values list");
+  "invalid none on values list");
 
 static_assert(
-	brigand::none<brigand::list<int, int, char>, std::is_floating_point<brigand::_1>>::value,
-	"invalid none on list");
+  brigand::none<brigand::list<int, int, char>, std::is_floating_point<brigand::_1>>::value,
+  "invalid none on list");
 
 static_assert(!brigand::any<brigand::empty_sequence>::value, "invalid any on empty list");
 
 static_assert(brigand::any<brigand::integral_list<int, 0, 0, 7, 0, 0, 0>>::value,
-	"invalid any on values list");
+  "invalid any on values list");
 
 static_assert(
-	brigand::any<brigand::list<int, int, double, char>, std::is_floating_point<brigand::_1>>::value,
-	"invalid any on list");
+  brigand::any<brigand::list<int, int, double, char>, std::is_floating_point<brigand::_1>>::value,
+  "invalid any on list");
 
 static_assert(brigand::all<brigand::empty_sequence>::value, "invalid all on empty list");
 
@@ -29,11 +29,11 @@ static_assert(brigand::any<brigand::integral_list<int, 1, 1, 1, 1>>::value, "inv
 static_assert(!brigand::any<brigand::integral_list<int, 0, 0, 0, 0>>::value, "invalid any list");
 
 static_assert(brigand::all<brigand::integral_list<int, 42, 69, 1337, 1664>>::value,
-	"invalid all on values list");
+  "invalid all on values list");
 
 static_assert(brigand::all<brigand::list<float, long double, double>,
-	std::is_floating_point<brigand::_1>>::value,
-	"invalid all on list");
+  std::is_floating_point<brigand::_1>>::value,
+  "invalid all on list");
 
 template <class...>
 class custom_list
@@ -46,20 +46,20 @@ brigand::wrap<brigand::integral_list<std::size_t, List...>, custom_list>;
 static_assert(brigand::none<custom_list<>>::value, "invalid none on empty list");
 
 static_assert(brigand::none<custom_integral_list<int, 0, 0, 0, 0, 0, 0>>::value,
-	"invalid none on values list");
+  "invalid none on values list");
 
 static_assert(
-	brigand::none<brigand::list<int, int, char>, std::is_floating_point<brigand::_1>>::value,
-	"invalid none on list");
+  brigand::none<brigand::list<int, int, char>, std::is_floating_point<brigand::_1>>::value,
+  "invalid none on list");
 
 static_assert(!brigand::any<custom_list<>>::value, "invalid any on empty list");
 
 static_assert(brigand::any<custom_integral_list<int, 0, 0, 7, 0, 0, 0>>::value,
-	"invalid any on values list");
+  "invalid any on values list");
 
 static_assert(
-	brigand::any<brigand::list<int, int, double, char>, std::is_floating_point<brigand::_1>>::value,
-	"invalid any on list");
+  brigand::any<brigand::list<int, int, double, char>, std::is_floating_point<brigand::_1>>::value,
+  "invalid any on list");
 
 static_assert(brigand::all<custom_list<>>::value, "invalid all on empty list");
 
@@ -67,8 +67,8 @@ static_assert(brigand::any<custom_integral_list<int, 1, 1, 1, 1>>::value, "inval
 static_assert(!brigand::any<custom_integral_list<int, 0, 0, 0, 0>>::value, "invalid any list");
 
 static_assert(brigand::all<custom_integral_list<int, 42, 69, 1337, 1664>>::value,
-	"invalid all on values list");
+  "invalid all on values list");
 
 static_assert(brigand::all<brigand::list<float, long double, double>,
-	std::is_floating_point<brigand::_1>>::value,
-	"invalid all on list");
\ No newline at end of file
+  std::is_floating_point<brigand::_1>>::value,
+  "invalid all on list");
diff --git a/test/remove_test.cpp b/test/remove_test.cpp
index 66d272d..b9a2cda 100644
--- a/test/remove_test.cpp
+++ b/test/remove_test.cpp
@@ -32,29 +32,29 @@ template<typename T, typename U>
 using greedy_and = typename brigand::and_<T, U>::type;
 
 static_assert(
-	std::is_same<brigand::remove_if<remove_test_int_list, brigand::bind<greedy_and, brigand::_1, brigand::_1>>,
-	brigand::integral_list<std::uint32_t, 0, 0>>::value,
-	"invalid remove_if result");
+  std::is_same<brigand::remove_if<remove_test_int_list, brigand::bind<greedy_and, brigand::_1, brigand::_1>>,
+  brigand::integral_list<std::uint32_t, 0, 0>>::value,
+  "invalid remove_if result");
 
 
 static_assert(std::is_same<brigand::filter<remove_test_int_list, brigand::not_<brigand::_1>>,
-	brigand::list<brigand::uint32_t<0>, brigand::uint32_t<0>>>::value,
-	"invalid remove_if result");
+  brigand::list<brigand::uint32_t<0>, brigand::uint32_t<0>>>::value,
+  "invalid remove_if result");
 
 static_assert(std::is_same<brigand::filter<remove_test_int_list,
-	brigand::not_<std::is_same<brigand::_1, brigand::uint32_t<2>>>>,
-	brigand::integral_list<std::uint32_t, 1, 0, 0>>::value,
-	"invalid remove_if result");
+  brigand::not_<std::is_same<brigand::_1, brigand::uint32_t<2>>>>,
+  brigand::integral_list<std::uint32_t, 1, 0, 0>>::value,
+  "invalid remove_if result");
 
 static_assert(
-	std::is_same<brigand::filter<remove_test_int_list, brigand::and_<brigand::_1, brigand::_1>>,
-	brigand::integral_list<std::uint32_t, 1, 2>>::value,
-	"invalid remove_if result");
+  std::is_same<brigand::filter<remove_test_int_list, brigand::and_<brigand::_1, brigand::_1>>,
+  brigand::integral_list<std::uint32_t, 1, 2>>::value,
+  "invalid remove_if result");
 
 static_assert(
-	std::is_same<brigand::filter<remove_test_int_list, brigand::bind<greedy_and, brigand::_1, brigand::_1>>,
-	brigand::integral_list<std::uint32_t, 1, 2>>::value,
-	"invalid remove_if result");
+  std::is_same<brigand::filter<remove_test_int_list, brigand::bind<greedy_and, brigand::_1, brigand::_1>>,
+  brigand::integral_list<std::uint32_t, 1, 2>>::value,
+  "invalid remove_if result");
 
 
 static_assert(std::is_same<brigand::remove<remove_test_list, int>,
diff --git a/test/replace.cpp b/test/replace.cpp
index 9714ceb..e4f3494 100644
--- a/test/replace.cpp
+++ b/test/replace.cpp
@@ -28,28 +28,28 @@ replace_test6 = brigand::list<int, long, char, long, int, unsigned int>{};
 
 namespace custom
 {
-	template <class...>
-	class custom_list
-	{
-	};
+  template <class...>
+  class custom_list
+  {
+  };
 
-	brigand::replace<custom_list<>, int, float> replace_on_empty_list = custom_list<>{};
+  brigand::replace<custom_list<>, int, float> replace_on_empty_list = custom_list<>{};
 
-	brigand::replace<custom_list<double, float>, int, float> replace_no_op =
-		custom_list<double, float>{};
+  brigand::replace<custom_list<double, float>, int, float> replace_no_op =
+    custom_list<double, float>{};
 
-	brigand::replace<custom_list<int>, int, float> replace_test1 = custom_list<float>{};
+  brigand::replace<custom_list<int>, int, float> replace_test1 = custom_list<float>{};
 
-	brigand::replace<custom_list<double>, int, float> replace_test2 = custom_list<double>{};
+  brigand::replace<custom_list<double>, int, float> replace_test2 = custom_list<double>{};
 
-	brigand::replace<custom_list<int, float>, int, float> replace_test3 = custom_list<float, float>{};
+  brigand::replace<custom_list<int, float>, int, float> replace_test3 = custom_list<float, float>{};
 
-	brigand::replace<custom_list<int, float, char, double, int, unsigned int>, int, float>
-		replace_test4 = custom_list<float, float, char, double, float, unsigned int>{};
+  brigand::replace<custom_list<int, float, char, double, int, unsigned int>, int, float>
+    replace_test4 = custom_list<float, float, char, double, float, unsigned int>{};
 
-	brigand::replace_if<custom_list<int, float, char, double, int, unsigned int>, pred_int, float>
-		replace_test5 = custom_list<float, float, float, double, float, float>{};
+  brigand::replace_if<custom_list<int, float, char, double, int, unsigned int>, pred_int, float>
+    replace_test5 = custom_list<float, float, float, double, float, float>{};
 
-	brigand::replace_if<custom_list<int, float, char, double, int, unsigned int>, pred_fp, long>
-		replace_test6 = custom_list<int, long, char, long, int, unsigned int>{};
+  brigand::replace_if<custom_list<int, float, char, double, int, unsigned int>, pred_fp, long>
+    replace_test6 = custom_list<int, long, char, long, int, unsigned int>{};
 }
diff --git a/test/sort_test.cpp b/test/sort_test.cpp
index f3073b1..5f63dd4 100644
--- a/test/sort_test.cpp
+++ b/test/sort_test.cpp
@@ -37,25 +37,25 @@ size_t_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15> sort_test13 =
 brigand::sort<size_t_list<15, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 13>>{};
 size_t_list<15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test14 =
 brigand::sort<size_t_list<1, 7, 8, 5, 13, 3, 9, 4, 10, 11, 12, 6, 14, 15, 2>,
-	brigand::greater<brigand::_1, brigand::_2>>{};
+  brigand::greater<brigand::_1, brigand::_2>>{};
 
 size_t_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16> sort_test15 =
 brigand::sort<size_t_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
 size_t_list<16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test16 =
 brigand::sort<size_t_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-	brigand::greater<brigand::_1, brigand::_2>>{};
+  brigand::greater<brigand::_1, brigand::_2>>{};
 
 size_t_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17> sort_test17 =
 brigand::sort<size_t_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
 size_t_list<17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test18 =
 brigand::sort<size_t_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-	brigand::greater<brigand::_1, brigand::_2>>{};
+  brigand::greater<brigand::_1, brigand::_2>>{};
 
 size_t_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18> sort_test19 =
 brigand::sort<size_t_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
 size_t_list<18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test20 =
 brigand::sort<size_t_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-	brigand::greater<brigand::_1, brigand::_2>>{};
+  brigand::greater<brigand::_1, brigand::_2>>{};
 
 brigand::empty_sequence sort_test21 = brigand::sort<brigand::empty_sequence>{};
 
@@ -71,89 +71,89 @@ using less_sizeof = brigand::bool_<sizeof(Lhs) < sizeof(Rhs)>;
 sorted_type_list sort_test23 = brigand::sort<type_list, brigand::bind<less_sizeof, brigand::_1, brigand::_2>>{};
 sorted_type_list sort_test24 =
 brigand::sort<type_list,
-	brigand::less<brigand::sizeof_<brigand::_1>, brigand::sizeof_<brigand::_2>>>{};
+  brigand::less<brigand::sizeof_<brigand::_1>, brigand::sizeof_<brigand::_2>>>{};
 
 size_t_list<1, 2> sort_test25 = brigand::sort<size_t_list<2, 1>>{};
 size_t_list<1> sort_test26 = brigand::sort<size_t_list<1>>{};
 
 namespace custom
 {
-	template <class...>
-	class custom_list
-	{
-	};
-
-	template <int... Is>
-	using custom_int_list = brigand::wrap<brigand::integral_list<int, Is...>, custom_list>;
-
-	custom_int_list<4> sort_test1 = brigand::sort<custom_int_list<4>>{};
-	custom_int_list<4> sort_test2 =
-		brigand::sort<custom_int_list<4>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 4> sort_test3 = brigand::sort<custom_int_list<1, 4>>{};
-	custom_int_list<4, 1> sort_test4 =
-		brigand::sort<custom_int_list<1, 4>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3> sort_test5 = brigand::sort<custom_int_list<3, 2, 1>>{};
-	custom_int_list<3, 2, 1> sort_test6 =
-		brigand::sort<custom_int_list<3, 2, 1>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 1, 2, 3, 4, 5, 7> sort_test7 =
-		brigand::sort<custom_int_list<3, 7, 5, 2, 1, 1, 4>>{};
-	custom_int_list<7, 5, 4, 3, 2, 1, 1> sort_test8 =
-		brigand::sort<custom_int_list<3, 5, 2, 1, 4, 1, 7>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3, 4, 5, 7, 8, 9> sort_test9 =
-		brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4>>{};
-	custom_int_list<9, 8, 7, 5, 4, 3, 2, 1> sort_test10 =
-		brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 1, 2, 3, 4, 5, 7, 8, 9> sort_test11 =
-		brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4, 1>>{};
-	custom_int_list<9, 8, 7, 5, 4, 3, 2, 1, 1> sort_test12 =
-		brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4, 1>, brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15> sort_test13 =
-		brigand::sort<custom_int_list<15, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 13>>{};
-	custom_int_list<15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test14 =
-		brigand::sort<custom_int_list<1, 7, 8, 5, 13, 3, 9, 4, 10, 11, 12, 6, 14, 15, 2>,
-		brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16> sort_test15 =
-		brigand::sort<custom_int_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
-	custom_int_list<16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test16 =
-		brigand::sort<custom_int_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-		brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17> sort_test17 =
-		brigand::sort<custom_int_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
-	custom_int_list<17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test18 =
-		brigand::sort<custom_int_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-		brigand::greater<brigand::_1, brigand::_2>>{};
-
-	custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18> sort_test19 =
-		brigand::sort<custom_int_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
-	custom_int_list<18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test20 =
-		brigand::sort<custom_int_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
-		brigand::greater<brigand::_1, brigand::_2>>{};
-
-	brigand::empty_sequence sort_test21 = brigand::sort<brigand::empty_sequence>{};
-
-	using sorted = custom_int_list<0, 1, 2, 3, 4>;
-	sorted sort_test22 = brigand::sort<sorted>{};
-
-	using type_list = brigand::list<double, short, char, int>;
-	using sorted_type_list = brigand::list<char, short, int, double>;
-
-	template <typename Lhs, typename Rhs>
-	using less_sizeof = brigand::bool_<sizeof(Lhs) < sizeof(Rhs)>;
-
-	sorted_type_list sort_test23 = brigand::sort<type_list, brigand::bind<less_sizeof, brigand::_1, brigand::_2>>{};
-	sorted_type_list sort_test24 =
-		brigand::sort<type_list,
-		brigand::less<brigand::sizeof_<brigand::_1>, brigand::sizeof_<brigand::_2>>>{};
-
-	custom_int_list<1, 2> sort_test25 = brigand::sort<custom_int_list<2, 1>>{};
-	custom_int_list<1> sort_test26 = brigand::sort<custom_int_list<1>>{};
+  template <class...>
+  class custom_list
+  {
+  };
+
+  template <int... Is>
+  using custom_int_list = brigand::wrap<brigand::integral_list<int, Is...>, custom_list>;
+
+  custom_int_list<4> sort_test1 = brigand::sort<custom_int_list<4>>{};
+  custom_int_list<4> sort_test2 =
+    brigand::sort<custom_int_list<4>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 4> sort_test3 = brigand::sort<custom_int_list<1, 4>>{};
+  custom_int_list<4, 1> sort_test4 =
+    brigand::sort<custom_int_list<1, 4>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3> sort_test5 = brigand::sort<custom_int_list<3, 2, 1>>{};
+  custom_int_list<3, 2, 1> sort_test6 =
+    brigand::sort<custom_int_list<3, 2, 1>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 1, 2, 3, 4, 5, 7> sort_test7 =
+    brigand::sort<custom_int_list<3, 7, 5, 2, 1, 1, 4>>{};
+  custom_int_list<7, 5, 4, 3, 2, 1, 1> sort_test8 =
+    brigand::sort<custom_int_list<3, 5, 2, 1, 4, 1, 7>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3, 4, 5, 7, 8, 9> sort_test9 =
+    brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4>>{};
+  custom_int_list<9, 8, 7, 5, 4, 3, 2, 1> sort_test10 =
+    brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 1, 2, 3, 4, 5, 7, 8, 9> sort_test11 =
+    brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4, 1>>{};
+  custom_int_list<9, 8, 7, 5, 4, 3, 2, 1, 1> sort_test12 =
+    brigand::sort<custom_int_list<3, 7, 8, 5, 2, 1, 9, 4, 1>, brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15> sort_test13 =
+    brigand::sort<custom_int_list<15, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 13>>{};
+  custom_int_list<15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test14 =
+    brigand::sort<custom_int_list<1, 7, 8, 5, 13, 3, 9, 4, 10, 11, 12, 6, 14, 15, 2>,
+    brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16> sort_test15 =
+    brigand::sort<custom_int_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
+  custom_int_list<16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test16 =
+    brigand::sort<custom_int_list<16, 3, 7, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
+    brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17> sort_test17 =
+    brigand::sort<custom_int_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
+  custom_int_list<17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test18 =
+    brigand::sort<custom_int_list<3, 7, 16, 17, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
+    brigand::greater<brigand::_1, brigand::_2>>{};
+
+  custom_int_list<1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18> sort_test19 =
+    brigand::sort<custom_int_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>>{};
+  custom_int_list<18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1> sort_test20 =
+    brigand::sort<custom_int_list<3, 7, 16, 17, 18, 8, 5, 2, 1, 9, 4, 10, 11, 12, 6, 14, 15, 13>,
+    brigand::greater<brigand::_1, brigand::_2>>{};
+
+  brigand::empty_sequence sort_test21 = brigand::sort<brigand::empty_sequence>{};
+
+  using sorted = custom_int_list<0, 1, 2, 3, 4>;
+  sorted sort_test22 = brigand::sort<sorted>{};
+
+  using type_list = brigand::list<double, short, char, int>;
+  using sorted_type_list = brigand::list<char, short, int, double>;
+
+  template <typename Lhs, typename Rhs>
+  using less_sizeof = brigand::bool_<sizeof(Lhs) < sizeof(Rhs)>;
+
+  sorted_type_list sort_test23 = brigand::sort<type_list, brigand::bind<less_sizeof, brigand::_1, brigand::_2>>{};
+  sorted_type_list sort_test24 =
+    brigand::sort<type_list,
+    brigand::less<brigand::sizeof_<brigand::_1>, brigand::sizeof_<brigand::_2>>>{};
+
+  custom_int_list<1, 2> sort_test25 = brigand::sort<custom_int_list<2, 1>>{};
+  custom_int_list<1> sort_test26 = brigand::sort<custom_int_list<1>>{};
 }
 
diff --git a/test/transform.cpp b/test/transform.cpp
index b660aff..43e2b11 100644
--- a/test/transform.cpp
+++ b/test/transform.cpp
@@ -20,7 +20,7 @@ using list2 = brigand::list<float, double, int, char, void *>;
 using expect2 = brigand::list<float *, double *, int *, char *, void **>;
 using expect2b =
 brigand::list<std::pair<float, float>, std::pair<double, double>, std::pair<int, int>,
-	std::pair<char, char>, std::pair<void *, void *>>;
+  std::pair<char, char>, std::pair<void *, void *>>;
 using expect2c = brigand::list<float *, double *, int *, char *, void *>;
 
 // local functors to apply
@@ -28,166 +28,166 @@ using ptr_t = std::add_pointer<brigand::_1>;
 using pair_t = brigand::bind<std::pair, brigand::_1, brigand::_2>;
 
 static_assert(std::is_same<brigand::transform<list0, std::add_pointer<brigand::_1>>, list0>::value,
-	"invalid unary transform on empty list");
+  "invalid unary transform on empty list");
 
 static_assert(std::is_same<brigand::transform<list0, ptr_t>, list0>::value,
-	"invalid unary transform on empty list");
+  "invalid unary transform on empty list");
 
 static_assert(std::is_same<brigand::transform<list0, list0, pair_t>, list0>::value,
-	"invalid binary transform on empty list");
+  "invalid binary transform on empty list");
 
 static_assert(std::is_same<brigand::transform<list1, ptr_t>, expect1>::value,
-	"invalid unary transform on list");
+  "invalid unary transform on list");
 
 static_assert(
-	std::is_same<brigand::transform<list1, std::add_pointer<brigand::_1>>, expect1>::value,
-	"invalid unary transform on list");
+  std::is_same<brigand::transform<list1, std::add_pointer<brigand::_1>>, expect1>::value,
+  "invalid unary transform on list");
 
 static_assert(std::is_same<brigand::transform<list1, list1, pair_t>, expect1b>::value,
-	"invalid binary transform on list");
+  "invalid binary transform on list");
 
 static_assert(std::is_same<brigand::transform<list2, ptr_t>, expect2>::value,
-	"invalid unary transform on list");
+  "invalid unary transform on list");
 
 static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
-	"invalid binary transform on list");
+  "invalid binary transform on list");
 
 static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
-	"invalid binary transform on list");
+  "invalid binary transform on list");
 
 static_assert(std::is_same<brigand::transform<
-	brigand::list<char, short, int>,
-	brigand::list<float, double, long double>,
-	brigand::list<unsigned, void, void*>,
-	brigand::bind<brigand::list, brigand::_1, brigand::_2, brigand::_3>
+  brigand::list<char, short, int>,
+  brigand::list<float, double, long double>,
+  brigand::list<unsigned, void, void*>,
+  brigand::bind<brigand::list, brigand::_1, brigand::_2, brigand::_3>
 >, brigand::list<
-	brigand::list<char, float, unsigned>,
-	brigand::list<short, double, void>,
-	brigand::list<int, long double, void*>
-	>>::value, "invalid transform on list");
+  brigand::list<char, float, unsigned>,
+  brigand::list<short, double, void>,
+  brigand::list<int, long double, void*>
+  >>::value, "invalid transform on list");
 
 static_assert(std::is_same<brigand::transform<
-	brigand::list<char, short, int>,
-	brigand::list<float, double, long double>,
-	brigand::list<unsigned, void, void*>,
-	brigand::list<char*, int*, long*>,
-	brigand::bind<brigand::list, brigand::_1, brigand::_2, brigand::_3, brigand::_4>
+  brigand::list<char, short, int>,
+  brigand::list<float, double, long double>,
+  brigand::list<unsigned, void, void*>,
+  brigand::list<char*, int*, long*>,
+  brigand::bind<brigand::list, brigand::_1, brigand::_2, brigand::_3, brigand::_4>
 >, brigand::list<
-	brigand::list<char, float, unsigned, char*>,
-	brigand::list<short, double, void, int*>,
-	brigand::list<int, long double, void*, long*>
-	>>::value, "invalid transform on list");
+  brigand::list<char, float, unsigned, char*>,
+  brigand::list<short, double, void, int*>,
+  brigand::list<int, long double, void*, long*>
+  >>::value, "invalid transform on list");
 
 static_assert(
-	std::is_same<
-	brigand::transform<brigand::list<void, char, int>,
-	std::add_pointer<std::add_pointer<std::add_pointer<brigand::_1>>>>,
-	brigand::list<void ***, char ***, int ***>>::value,
-	"invalid transform on list");
+  std::is_same<
+  brigand::transform<brigand::list<void, char, int>,
+  std::add_pointer<std::add_pointer<std::add_pointer<brigand::_1>>>>,
+  brigand::list<void ***, char ***, int ***>>::value,
+  "invalid transform on list");
 
 static_assert(std::is_same<brigand::transform<list2, brigand::if_<std::is_pointer<brigand::_1>,
-	brigand::identity<brigand::_1>,
-	std::add_pointer<brigand::_1>>>,
-	expect2c>::value,
-	"invalid binary transform on list");
+  brigand::identity<brigand::_1>,
+  std::add_pointer<brigand::_1>>>,
+  expect2c>::value,
+  "invalid binary transform on list");
 
 using sum_list = brigand::integral_list<int, 1, 2, 3>;
 
 static_assert(std::is_same<brigand::as_integral_list<brigand::transform<
-	sum_list, sum_list, brigand::plus<brigand::_1, brigand::_2>>>,
-	brigand::integral_list<int, 2, 4, 6>>::value,
-	"invalid transform sum");
+  sum_list, sum_list, brigand::plus<brigand::_1, brigand::_2>>>,
+  brigand::integral_list<int, 2, 4, 6>>::value,
+  "invalid transform sum");
 
 static_assert(
-	std::is_same<brigand::as_integral_list<brigand::transform<
-	sum_list, brigand::plus<brigand::_1, std::integral_constant<int, 2>>>>,
-	brigand::integral_list<int, 3, 4, 5>>::value,
-	"invalid transform sum");
+  std::is_same<brigand::as_integral_list<brigand::transform<
+  sum_list, brigand::plus<brigand::_1, std::integral_constant<int, 2>>>>,
+  brigand::integral_list<int, 3, 4, 5>>::value,
+  "invalid transform sum");
 
 static_assert(
-	std::is_same<brigand::as_integral_list<brigand::transform<
-	sum_list, brigand::minus<std::integral_constant<int, 10>, brigand::_1>>>,
-	brigand::integral_list<int, 9, 8, 7>>::value,
-	"invalid transform sum");
+  std::is_same<brigand::as_integral_list<brigand::transform<
+  sum_list, brigand::minus<std::integral_constant<int, 10>, brigand::_1>>>,
+  brigand::integral_list<int, 9, 8, 7>>::value,
+  "invalid transform sum");
 
 namespace custom
 {
-	template <class...>
-	class custom_list
-	{
-	};
-
-	template <int... Is>
-	using custom_int_list = brigand::wrap<brigand::integral_list<int, Is...>, custom_list>;
-	using list0 = custom_list<>;
-
-	using list1 = custom_list<int>;
-	using expect1 = custom_list<int *>;
-	using expect1b = custom_list<std::pair<int, int>>;
-
-	using list2 = custom_list<float, double, int, char, void *>;
-	using expect2 = custom_list<float *, double *, int *, char *, void **>;
-	using expect2b = custom_list<std::pair<float, float>, std::pair<double, double>,
-		std::pair<int, int>, std::pair<char, char>, std::pair<void *, void *>>;
-	using expect2c = custom_list<float *, double *, int *, char *, void *>;
-
-	static_assert(std::is_same<brigand::transform<list0, std::add_pointer<brigand::_1>>, list0>::value,
-		"invalid unary transform on empty list");
-
-	static_assert(std::is_same<brigand::transform<list0, ptr_t>, list0>::value,
-		"invalid unary transform on empty list");
-
-	static_assert(std::is_same<brigand::transform<list0, list0, pair_t>, list0>::value,
-		"invalid binary transform on empty list");
-
-	static_assert(std::is_same<brigand::transform<list1, ptr_t>, expect1>::value,
-		"invalid unary transform on list");
-
-	static_assert(
-		std::is_same<brigand::transform<list1, std::add_pointer<brigand::_1>>, expect1>::value,
-		"invalid unary transform on list");
-
-	static_assert(std::is_same<brigand::transform<list1, list1, pair_t>, expect1b>::value,
-		"invalid binary transform on list");
-
-	static_assert(std::is_same<brigand::transform<list2, ptr_t>, expect2>::value,
-		"invalid unary transform on list");
-
-	static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
-		"invalid binary transform on list");
-
-	static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
-		"invalid binary transform on list");
-
-	static_assert(
-		std::is_same<
-		brigand::transform<custom_list<void, char, int>,
-		std::add_pointer<std::add_pointer<std::add_pointer<brigand::_1>>>>,
-		custom_list<void ***, char ***, int ***>>::value,
-		"invalid transform on list");
-
-	static_assert(std::is_same<brigand::transform<list2, brigand::if_<std::is_pointer<brigand::_1>,
-		brigand::identity<brigand::_1>,
-		std::add_pointer<brigand::_1>>>,
-		expect2c>::value,
-		"invalid binary transform on list");
-
-	using sum_list = custom_int_list<1, 2, 3>;
-
-	static_assert(std::is_same<brigand::as_integral_list<brigand::transform<
-		sum_list, sum_list, brigand::plus<brigand::_1, brigand::_2>>>,
-		custom_int_list<2, 4, 6>>::value,
-		"invalid transform sum");
-
-	static_assert(
-		std::is_same<brigand::as_integral_list<brigand::transform<
-		sum_list, brigand::plus<brigand::_1, std::integral_constant<int, 2>>>>,
-		custom_int_list<3, 4, 5>>::value,
-		"invalid transform sum");
-
-	static_assert(
-		std::is_same<brigand::as_integral_list<brigand::transform<
-		sum_list, brigand::minus<std::integral_constant<int, 10>, brigand::_1>>>,
-		custom_int_list<9, 8, 7>>::value,
-		"invalid transform sum");
+  template <class...>
+  class custom_list
+  {
+  };
+
+  template <int... Is>
+  using custom_int_list = brigand::wrap<brigand::integral_list<int, Is...>, custom_list>;
+  using list0 = custom_list<>;
+
+  using list1 = custom_list<int>;
+  using expect1 = custom_list<int *>;
+  using expect1b = custom_list<std::pair<int, int>>;
+
+  using list2 = custom_list<float, double, int, char, void *>;
+  using expect2 = custom_list<float *, double *, int *, char *, void **>;
+  using expect2b = custom_list<std::pair<float, float>, std::pair<double, double>,
+    std::pair<int, int>, std::pair<char, char>, std::pair<void *, void *>>;
+  using expect2c = custom_list<float *, double *, int *, char *, void *>;
+
+  static_assert(std::is_same<brigand::transform<list0, std::add_pointer<brigand::_1>>, list0>::value,
+    "invalid unary transform on empty list");
+
+  static_assert(std::is_same<brigand::transform<list0, ptr_t>, list0>::value,
+    "invalid unary transform on empty list");
+
+  static_assert(std::is_same<brigand::transform<list0, list0, pair_t>, list0>::value,
+    "invalid binary transform on empty list");
+
+  static_assert(std::is_same<brigand::transform<list1, ptr_t>, expect1>::value,
+    "invalid unary transform on list");
+
+  static_assert(
+    std::is_same<brigand::transform<list1, std::add_pointer<brigand::_1>>, expect1>::value,
+    "invalid unary transform on list");
+
+  static_assert(std::is_same<brigand::transform<list1, list1, pair_t>, expect1b>::value,
+    "invalid binary transform on list");
+
+  static_assert(std::is_same<brigand::transform<list2, ptr_t>, expect2>::value,
+    "invalid unary transform on list");
+
+  static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
+    "invalid binary transform on list");
+
+  static_assert(std::is_same<brigand::transform<list2, list2, pair_t>, expect2b>::value,
+    "invalid binary transform on list");
+
+  static_assert(
+    std::is_same<
+    brigand::transform<custom_list<void, char, int>,
+    std::add_pointer<std::add_pointer<std::add_pointer<brigand::_1>>>>,
+    custom_list<void ***, char ***, int ***>>::value,
+    "invalid transform on list");
+
+  static_assert(std::is_same<brigand::transform<list2, brigand::if_<std::is_pointer<brigand::_1>,
+    brigand::identity<brigand::_1>,
+    std::add_pointer<brigand::_1>>>,
+    expect2c>::value,
+    "invalid binary transform on list");
+
+  using sum_list = custom_int_list<1, 2, 3>;
+
+  static_assert(std::is_same<brigand::as_integral_list<brigand::transform<
+    sum_list, sum_list, brigand::plus<brigand::_1, brigand::_2>>>,
+    custom_int_list<2, 4, 6>>::value,
+    "invalid transform sum");
+
+  static_assert(
+    std::is_same<brigand::as_integral_list<brigand::transform<
+    sum_list, brigand::plus<brigand::_1, std::integral_constant<int, 2>>>>,
+    custom_int_list<3, 4, 5>>::value,
+    "invalid transform sum");
+
+  static_assert(
+    std::is_same<brigand::as_integral_list<brigand::transform<
+    sum_list, brigand::minus<std::integral_constant<int, 10>, brigand::_1>>>,
+    custom_int_list<9, 8, 7>>::value,
+    "invalid transform sum");
 }