diff --git a/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp b/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
index 29797ef3..aafe18d8 100644
--- a/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
+++ b/include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp
@@ -18,16 +18,20 @@
 
 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_<fusion::traits::is_sequence<Seq1>, fusion::traits::is_sequence<Seq2> >
+        : mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
     {};
 
     template <typename Seq1, typename Seq2>
     struct enable_comparison
         : mpl::and_<
-        mpl::or_<fusion::traits::is_sequence<Seq1>, fusion::traits::is_sequence<Seq2> >,
-        mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> > >
+            mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
+          , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> > 
+        >
     {};
 
 }}}
diff --git a/include/boost/fusion/sequence/comparison/equal_to.hpp b/include/boost/fusion/sequence/comparison/equal_to.hpp
index ee04a24f..83d52dee 100644
--- a/include/boost/fusion/sequence/comparison/equal_to.hpp
+++ b/include/boost/fusion/sequence/comparison/equal_to.hpp
@@ -14,28 +14,34 @@
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
 #include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
-    namespace sequence_operators
+    template <typename Seq1, typename Seq2>
+    inline bool
+    equal_to(Seq1 const& a, Seq2 const& b)
+    {
+        return result_of::size<Seq1>::value == result_of::size<Seq2>::value
+            && detail::sequence_equal_to<
+            Seq1 const, Seq2 const
+            , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
+            call(fusion::begin(a), fusion::begin(b));
+    }
+
+    namespace operators
     {
         template <typename Seq1, typename Seq2>
-        inline typename 
-        enable_if<
-            detail::enable_equality<Seq1, Seq2>
-            , bool
+        inline typename
+            enable_if<
+                detail::enable_equality<Seq1, Seq2>
+              , bool
             >::type
         operator==(Seq1 const& a, Seq2 const& b)
         {
-            return result_of::size<Seq1>::value == result_of::size<Seq2>::value
-                && detail::sequence_equal_to<
-                Seq1 const, Seq2 const
-                , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
-                call(fusion::begin(a), fusion::begin(b));
+            return fusion::equal_to(a, b);
         }
     }
-    using sequence_operators::operator==;
+    using operators::operator==;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/comparison/greater.hpp b/include/boost/fusion/sequence/comparison/greater.hpp
index becd6767..dd57ebef 100644
--- a/include/boost/fusion/sequence/comparison/greater.hpp
+++ b/include/boost/fusion/sequence/comparison/greater.hpp
@@ -12,6 +12,7 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
 
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
 #include <boost/fusion/sequence/comparison/detail/greater.hpp>
@@ -19,18 +20,11 @@
 #include <boost/fusion/sequence/comparison/less.hpp>
 #endif
 
-#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
     template <typename Seq1, typename Seq2>
-    inline typename 
-        enable_if<
-            detail::enable_comparison<Seq1, Seq2>
-          , bool
-        >::type
-    operator>(Seq1 const& a, Seq2 const& b)
+    inline bool
+    greater(Seq1 const& a, Seq2 const& b)
     {
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
         return detail::sequence_greater<Seq1 const, Seq2 const>::
@@ -39,6 +33,21 @@ namespace boost { namespace fusion
         return (b < a);
 #endif
     }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater(a, b);
+        }
+    }
+    using operators::operator>;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/comparison/greater_equal.hpp b/include/boost/fusion/sequence/comparison/greater_equal.hpp
index f73ee64f..a0b9baef 100644
--- a/include/boost/fusion/sequence/comparison/greater_equal.hpp
+++ b/include/boost/fusion/sequence/comparison/greater_equal.hpp
@@ -12,6 +12,7 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
 
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
 #include <boost/fusion/sequence/comparison/detail/greater_equal.hpp>
@@ -19,18 +20,11 @@
 #include <boost/fusion/sequence/comparison/less.hpp>
 #endif
 
-#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
     template <typename Seq1, typename Seq2>
-    inline typename 
-        enable_if<
-            detail::enable_comparison<Seq1, Seq2>
-          , bool
-        >::type
-    operator>=(Seq1 const& a, Seq2 const& b)
+    inline bool
+    greater_equal(Seq1 const& a, Seq2 const& b)
     {
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
         return detail::sequence_greater_equal<Seq1 const, Seq2 const>::
@@ -39,6 +33,21 @@ namespace boost { namespace fusion
         return !(a < b);
 #endif
     }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator>=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::greater_equal(a, b);
+        }
+    }
+    using operators::operator>=;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/comparison/less.hpp b/include/boost/fusion/sequence/comparison/less.hpp
index 96d13d41..b5abddeb 100644
--- a/include/boost/fusion/sequence/comparison/less.hpp
+++ b/include/boost/fusion/sequence/comparison/less.hpp
@@ -14,21 +14,31 @@
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/sequence/comparison/detail/less.hpp>
 #include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
     template <typename Seq1, typename Seq2>
-    inline typename 
-        enable_if<
-            detail::enable_comparison<Seq1, Seq2>
-          , bool
-        >::type
-    operator<(Seq1 const& a, Seq2 const& b)
+    inline bool
+    less(Seq1 const& a, Seq2 const& b)
     {
         return detail::sequence_less<Seq1 const, Seq2 const>::
             call(fusion::begin(a), fusion::begin(b));
     }
+
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less(a, b);
+        }
+    }
+    using operators::operator<;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/comparison/less_equal.hpp b/include/boost/fusion/sequence/comparison/less_equal.hpp
index d4b45b2d..71d25328 100644
--- a/include/boost/fusion/sequence/comparison/less_equal.hpp
+++ b/include/boost/fusion/sequence/comparison/less_equal.hpp
@@ -12,6 +12,7 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
 
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
 #include <boost/fusion/sequence/comparison/detail/less_equal.hpp>
@@ -19,18 +20,11 @@
 #include <boost/fusion/sequence/comparison/less.hpp>
 #endif
 
-#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
     template <typename Seq1, typename Seq2>
-    inline typename 
-        enable_if<
-            detail::enable_comparison<Seq1, Seq2>
-          , bool
-        >::type
-    operator<=(Seq1 const& a, Seq2 const& b)
+    inline bool
+    less_equal(Seq1 const& a, Seq2 const& b)
     {
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
         return detail::sequence_less_equal<Seq1 const, Seq2 const>::
@@ -39,6 +33,49 @@ namespace boost { namespace fusion
         return !(b < a);
 #endif
     }
+
+    namespace operators
+    {
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1400) 
+// Workaround for  VC8.0 and VC7.1
+        template <typename Seq1, typename Seq2>
+        inline bool
+        operator<=(sequence_base<Seq1> const& a, sequence_base<Seq2> const& b)
+        {
+            return less_equal(a.derived(), b.derived());
+        }
+
+        template <typename Seq1, typename Seq2>
+        inline typename disable_if<detail::is_native_fusion_sequence<Seq2>, bool>::type
+        operator<=(sequence_base<Seq1> const& a, Seq2 const& b)
+        {
+            return less_equal(a.derived(), b);
+        }
+
+        template <typename Seq1, typename Seq2>
+        inline typename disable_if<detail::is_native_fusion_sequence<Seq1>, bool>::type
+        operator<=(Seq1 const& a, sequence_base<Seq2> const& b)
+        {
+            return less_equal(a, b.derived());
+        }
+
+#else
+// Somehow VC8.0 and VC7.1 does not like this code
+// but barfs somewhere else. 
+
+        template <typename Seq1, typename Seq2>
+        inline typename
+            enable_if<
+                detail::enable_comparison<Seq1, Seq2>
+              , bool
+            >::type
+        operator<=(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::less_equal(a, b);
+        }
+#endif
+    }
+    using operators::operator<=;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/comparison/not_equal_to.hpp b/include/boost/fusion/sequence/comparison/not_equal_to.hpp
index 1464d023..4fd87301 100644
--- a/include/boost/fusion/sequence/comparison/not_equal_to.hpp
+++ b/include/boost/fusion/sequence/comparison/not_equal_to.hpp
@@ -12,6 +12,7 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
 
 #if defined(FUSION_DIRECT_OPERATOR_USAGE)
 #include <boost/fusion/sequence/comparison/detail/not_equal_to.hpp>
@@ -19,34 +20,37 @@
 #include <boost/fusion/sequence/comparison/equal_to.hpp>
 #endif
 
-#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
-    namespace sequence_operators
+    template <typename Seq1, typename Seq2>
+    inline bool
+    not_equal_to(Seq1 const& a, Seq2 const& b)
+    {
+#if defined(FUSION_DIRECT_OPERATOR_USAGE)
+        return result_of::size<Seq1>::value != result_of::size<Seq2>::value
+            || detail::sequence_not_equal_to<
+            Seq1 const, Seq2 const
+            , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
+            call(fusion::begin(a), fusion::begin(b));
+#else
+        return !(a == b);
+#endif
+    }
+
+    namespace operators
     {
         template <typename Seq1, typename Seq2>
-        inline typename 
-        enable_if<
-            detail::enable_equality<Seq1, Seq2>
-            , bool
+        inline typename
+            enable_if<
+                detail::enable_equality<Seq1, Seq2>
+              , bool
             >::type
         operator!=(Seq1 const& a, Seq2 const& b)
         {
-#if defined(FUSION_DIRECT_OPERATOR_USAGE)
-            return result_of::size<Seq1>::value != result_of::size<Seq2>::value
-                || detail::sequence_not_equal_to<
-                Seq1 const, Seq2 const
-                , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
-                call(fusion::begin(a), fusion::begin(b));
-#else
-            return !(a == b);
-#endif
+            return fusion::not_equal_to(a, b);
         }
     }
-
-    using sequence_operators::operator!=;
+    using operators::operator!=;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/io/in.hpp b/include/boost/fusion/sequence/io/in.hpp
index c3e5a1c5..2a946e3d 100644
--- a/include/boost/fusion/sequence/io/in.hpp
+++ b/include/boost/fusion/sequence/io/in.hpp
@@ -12,23 +12,32 @@
 
 #include <istream>
 #include <boost/fusion/sequence/io/detail/in.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/or.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
 
 namespace boost { namespace fusion
 {
     template <typename Sequence>
-    inline typename
-        enable_if<
-            fusion::traits::is_sequence<Sequence>
-          , std::istream&
-        >::type
-    operator>>(std::istream& is, Sequence& seq)
+    inline std::istream&
+    in(std::istream& is, Sequence& seq)
     {
         detail::read_sequence(is, seq);
         return is;
     }
+    
+    namespace operators
+    {
+        template <typename Sequence>
+        inline typename
+            enable_if<
+               fusion::traits::is_sequence<Sequence>
+              , std::istream&
+            >::type
+        operator>>(std::istream& is, Sequence& seq)
+        {
+            return fusion::in(is, seq);
+        }
+    }
+    using operators::operator>>;
 }}
 
 #endif
diff --git a/include/boost/fusion/sequence/io/out.hpp b/include/boost/fusion/sequence/io/out.hpp
index 00491b8b..2c8cea2d 100644
--- a/include/boost/fusion/sequence/io/out.hpp
+++ b/include/boost/fusion/sequence/io/out.hpp
@@ -19,16 +19,27 @@
 namespace boost { namespace fusion
 {
     template <typename Sequence>
-    inline typename
-        enable_if<
-           fusion::traits::is_sequence<Sequence>
-          , std::ostream&
-        >::type
-    operator<<(std::ostream& os, Sequence const& seq)
+    inline std::ostream&
+    out(std::ostream& os, Sequence& seq)
     {
         detail::print_sequence(os, seq);
         return os;
     }
+    
+    namespace operators
+    {
+        template <typename Sequence>
+        inline typename
+            enable_if<
+               fusion::traits::is_sequence<Sequence>
+              , std::ostream&
+            >::type
+        operator<<(std::ostream& os, Sequence const& seq)
+        {
+            return fusion::out(os, seq);
+        }
+    }
+    using operators::operator<<;
 }}
 
 #endif