diff --git a/brigand/adapted/integral_list.hpp b/brigand/adapted/integral_list.hpp
index da88255..05f18fe 100644
--- a/brigand/adapted/integral_list.hpp
+++ b/brigand/adapted/integral_list.hpp
@@ -15,6 +15,6 @@ namespace brigand
 	struct make_integral : std::integral_constant < typename T::value_type, T::value > {};
 	
 	template <typename L>
-	using as_integral_list = transform < make_integral<brigand::_1>, L > ;
+	using as_integral_list = transform <L, make_integral<brigand::_1>> ;
 
 }
\ No newline at end of file
diff --git a/brigand/algorithms/fold.hpp b/brigand/algorithms/fold.hpp
index d126e57..e83c857 100644
--- a/brigand/algorithms/fold.hpp
+++ b/brigand/algorithms/fold.hpp
@@ -12,6 +12,6 @@
 namespace brigand
 {
   // Main fold entry point
-  template<template<class,class> class Functor, class State, class Sequence>
+  template <class Sequence, class State, template<class,class> class Functor>
   using fold = typename detail::fold_impl<Functor, State, Sequence>::type;
 }
diff --git a/brigand/algorithms/transform.hpp b/brigand/algorithms/transform.hpp
index a4a1817..8411cf8 100644
--- a/brigand/algorithms/transform.hpp
+++ b/brigand/algorithms/transform.hpp
@@ -12,34 +12,55 @@ namespace brigand
 {
   namespace detail
   {
-    template<typename Functor, typename... Sequence>
-    struct transform_impl;
+
+	template <typename Functor, typename Sequence>
+	struct unary_transform_impl;
 
     // Unary transform implementation
     template< typename Functor
             , template<class...> class Sequence, typename... T
             >
-    struct transform_impl<Functor, Sequence<T...>>
+	struct unary_transform_impl<Functor, Sequence<T...>>
     {
       using type = Sequence< brigand::apply<Functor,T>... >;
     };
 
+	template<typename Functor, typename Sequence1, typename Sequence2>
+	struct binary_transform_impl;
+
     // Binary transform implementation
     template< typename Functor
             , template<class...> class Sequence1, typename... T1
             , template<class...> class Sequence2, typename... T2
             >
-    struct transform_impl<Functor, Sequence1<T1...>, Sequence2<T2...>>
+	struct binary_transform_impl<Functor, Sequence1<T1...>, Sequence2<T2...>>
     {
       static_assert ( sizeof...(T1) == sizeof...(T2)
                     , "The arguments of transform should be of the same size"
                     );
 
       using type = Sequence1< brigand::apply<Functor,T1,T2>... >;
-    };
+	};
+
+	template <std::size_t Selector, typename Sequence1, typename Functor, typename Sequence2 = void>
+	struct transform_selector;
+
+	template <typename Sequence1, typename Functor>
+	struct transform_selector <0, Sequence1, Functor, void>
+	{
+		using type = typename unary_transform_impl<Functor, Sequence1>::type;
+	};
+
+	template <typename Sequence1, typename Sequence2, typename Functor>
+	struct transform_selector<1, Sequence1, Sequence2, Functor>
+	{
+		using type = typename binary_transform_impl<Functor, Sequence1, Sequence2>::type;
+	};
+
   }
 
   // Main transform entry point
-  template<typename Functor, typename... Sequence >
-  using transform = typename detail::transform_impl<Functor, Sequence...>::type;
+  template<typename Sequence1, typename OpSeq1, typename... OpSeq2>
+  using transform = typename detail::transform_selector<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...>::type;
+
 }
diff --git a/test/fold.cpp b/test/fold.cpp
index 6b3d85b..6256080 100644
--- a/test/fold.cpp
+++ b/test/fold.cpp
@@ -23,8 +23,8 @@ using f_ = typename  std::conditional < std::is_floating_point<Element>::value
                                       , State
                                       >::type;
 
-static_assert(brigand::fold<f_,leet_,list0>::type::value  == 1337 , "invalid fold on empty list"    );
-static_assert(brigand::fold<f_,zero_,list1y>::type::value == 1    , "invalid fold on 1 element list");
-static_assert(brigand::fold<f_,zero_,list1n>::type::value == 0    , "invalid fold on 1 element list");
-static_assert(brigand::fold<f_,zero_,list6>::type::value  == 3    , "invalid fold on list"          );
-static_assert(brigand::fold<f_,c88,list12>::type::value   == 100  , "invalid fold with state"       );
+static_assert(brigand::fold<list0, leet_, f_>::type::value == 1337, "invalid fold on empty list");
+static_assert(brigand::fold<list1y, zero_, f_>::type::value == 1, "invalid fold on 1 element list");
+static_assert(brigand::fold<list1n, zero_, f_>::type::value == 0, "invalid fold on 1 element list");
+static_assert(brigand::fold<list6, zero_, f_>::type::value == 3, "invalid fold on list");
+static_assert(brigand::fold<list12, c88, f_>::type::value == 100, "invalid fold with state");
diff --git a/test/transform.cpp b/test/transform.cpp
index cac85d9..59a48be 100644
--- a/test/transform.cpp
+++ b/test/transform.cpp
@@ -27,75 +27,77 @@ using expect2c  = brigand::list<float*,double*,int*,char*,void*>;
 using ptr_t  = std::add_pointer<brigand::_1>;
 using pair_t = std::pair<brigand::_1,brigand::_2>;
 
-static_assert ( std::is_same< brigand::transform<std::add_pointer<brigand::_1>,list0>
+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<ptr_t,list0>
+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<pair_t,list0,list0>
+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<ptr_t,list1>
+static_assert ( std::is_same< brigand::transform<list1, ptr_t>
                             , expect1
                             >::value
               , "invalid unary transform on list"
               );
 
 
-static_assert ( std::is_same< brigand::transform<std::add_pointer<brigand::_1>,list1>
+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<pair_t,list1,list1>
+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<ptr_t,list2>
+static_assert (std::is_same< brigand::transform<list2, ptr_t>
                             , expect2
                             >::value
               , "invalid unary transform on list"
               );
 
-static_assert ( std::is_same< brigand::transform<pair_t,list2,list2>
+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<pair_t,list2,list2>
+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 < std::add_pointer<std::add_pointer<std::add_pointer<brigand::_1>>>,
-			brigand::list<void, char, int>>,
+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"
 );
 
 
-static_assert ( std::is_same< brigand::transform< brigand::if_< std::is_pointer<brigand::_1>
+static_assert ( std::is_same< brigand::transform<list2, brigand::if_< std::is_pointer<brigand::_1>
                                                               , brigand::identity<brigand::_1>
                                                               , std::add_pointer < brigand::_1 >
                                                               >
-                                                , list2
                                                 >
                             , expect2c
                             >::value
               , "invalid binary transform on list"
               );
+