diff --git a/include/boost/fusion/container/deque/deque.hpp b/include/boost/fusion/container/deque/deque.hpp
index b5c9edd8..c26a226c 100644
--- a/include/boost/fusion/container/deque/deque.hpp
+++ b/include/boost/fusion/container/deque/deque.hpp
@@ -27,6 +27,7 @@
 #include <boost/fusion/container/deque/detail/at_impl.hpp>
 #include <boost/fusion/container/deque/detail/begin_impl.hpp>
 #include <boost/fusion/container/deque/detail/end_impl.hpp>
+#include <boost/fusion/container/deque/detail/is_sequence_impl.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/mpl/bool.hpp>
 
diff --git a/include/boost/fusion/container/deque/detail/is_sequence_impl.hpp b/include/boost/fusion/container/deque/detail/is_sequence_impl.hpp
new file mode 100644
index 00000000..ff88ed6f
--- /dev/null
+++ b/include/boost/fusion/container/deque/detail/is_sequence_impl.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_CONTAINER_DEQUE_DETAIL_IS_SEQUENCE_IMPL_HPP
+#define BOOST_FUSION_CONTAINER_DEQUE_DETAIL_IS_SEQUENCE_IMPL_HPP
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion
+{
+    struct deque_tag;
+
+    namespace extension 
+    {
+        template<typename T>
+        struct is_sequence_impl;
+        
+        template<>
+        struct is_sequence_impl<deque_tag>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+    }
+}}
+
+#endif
diff --git a/include/boost/fusion/container/vector/detail/vector_n.hpp b/include/boost/fusion/container/vector/detail/vector_n.hpp
index ea314ac2..33484c5d 100644
--- a/include/boost/fusion/container/vector/detail/vector_n.hpp
+++ b/include/boost/fusion/container/vector/detail/vector_n.hpp
@@ -36,8 +36,8 @@
 
 #define N BOOST_PP_ITERATION()
 
-    template <typename Derived, BOOST_PP_ENUM_PARAMS(N, typename T)>
-    struct BOOST_PP_CAT(vector_data, N) : sequence_base<Derived>
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    struct BOOST_PP_CAT(vector_data, N)
     {
         BOOST_PP_CAT(vector_data, N)()
             : BOOST_PP_ENUM(N, FUSION_MEMBER_DEFAULT_INIT, _) {}
@@ -73,12 +73,11 @@
 
     template <BOOST_PP_ENUM_PARAMS(N, typename T)>
     struct BOOST_PP_CAT(vector, N)
-        : BOOST_PP_CAT(vector_data, N)<
-            BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)>
-          , BOOST_PP_ENUM_PARAMS(N, T)>
+      : BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)>
+      , sequence_base<BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> >
     {
         typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> this_type;
-        typedef BOOST_PP_CAT(vector_data, N)<this_type, BOOST_PP_ENUM_PARAMS(N, T)> base_type;
+        typedef BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)> base_type;
         typedef mpl::BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> types;
         typedef vector_tag fusion_tag;
         typedef fusion_sequence_tag tag; // this gets picked up by MPL
diff --git a/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp b/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
index 3e79277e..93d01506 100644
--- a/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
+++ b/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
@@ -13,22 +13,18 @@
 #include <boost/mpl/equal_to.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
-#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
 
 namespace boost { namespace fusion { namespace detail
 {
-    template <typename Sequence>
-    struct is_native_fusion_sequence : is_base_of<sequence_root, Sequence> {};
-
     template <typename Seq1, typename Seq2>
     struct enable_equality
-        : mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
+        : mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
     {};
 
     template <typename Seq1, typename Seq2>
     struct enable_comparison
         : mpl::and_<
-            mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
+            mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
           , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> > 
         >
     {};
diff --git a/include/boost/fusion/support/detail/is_mpl_sequence.hpp b/include/boost/fusion/support/detail/is_mpl_sequence.hpp
index eeb8f916..b7e792b3 100644
--- a/include/boost/fusion/support/detail/is_mpl_sequence.hpp
+++ b/include/boost/fusion/support/detail/is_mpl_sequence.hpp
@@ -9,17 +9,17 @@
 #define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105
 
 #include <boost/fusion/support/sequence_base.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 
 namespace boost { namespace fusion { namespace detail
 {
     template <typename T>
     struct is_mpl_sequence
         : mpl::and_<
-            mpl::not_<is_base_of<sequence_root, T> >
+            mpl::not_<is_convertible<T, from_sequence_convertible_type> >
           , mpl::is_sequence<T> >
     {};
 }}}
diff --git a/include/boost/fusion/support/is_sequence.hpp b/include/boost/fusion/support/is_sequence.hpp
index d57cecb4..4dc9bdd8 100644
--- a/include/boost/fusion/support/is_sequence.hpp
+++ b/include/boost/fusion/support/is_sequence.hpp
@@ -7,12 +7,13 @@
 #if !defined(FUSION_IS_SEQUENCE_05052005_1002)
 #define FUSION_IS_SEQUENCE_05052005_1002
 
-#include <boost/type_traits/is_base_of.hpp>
 #include <boost/fusion/support/sequence_base.hpp>
 #include <boost/fusion/support/tag_of.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 namespace boost { namespace fusion
 {
@@ -29,7 +30,9 @@ namespace boost { namespace fusion
         struct is_sequence_impl
         {
             template <typename Sequence>
-            struct apply : is_base_of<sequence_root, Sequence> {};
+            struct apply
+              : is_convertible<Sequence, detail::from_sequence_convertible_type>
+            {};
         };
 
         template <>
diff --git a/include/boost/fusion/support/sequence_base.hpp b/include/boost/fusion/support/sequence_base.hpp
index 1d436ef1..9a5186df 100644
--- a/include/boost/fusion/support/sequence_base.hpp
+++ b/include/boost/fusion/support/sequence_base.hpp
@@ -12,10 +12,14 @@
 
 namespace boost { namespace fusion
 {
-    struct sequence_root {};
+    namespace detail
+    {
+        struct from_sequence_convertible_type
+        {};
+    }
 
     template <typename Sequence>
-    struct sequence_base : sequence_root
+    struct sequence_base
     {
         Sequence const&
         derived() const
@@ -28,6 +32,11 @@ namespace boost { namespace fusion
         {
             return static_cast<Sequence&>(*this);
         }
+
+        operator detail::from_sequence_convertible_type()const
+        {
+            return detail::from_sequence_convertible_type();
+        }
     };
 
     struct fusion_sequence_tag;