Index: unfused.hpp
===================================================================
--- unfused.hpp	(revision 64741)
+++ unfused.hpp	(working copy)
@@ -31,58 +31,47 @@
 
 namespace boost { namespace fusion
 {
-    template <class Function, bool AllowNullary = true>
-    class unfused;
+    template <class Derived, template<typename> class Result, bool AllowNullary = true>
+    class unfuse_interface;
 
     //----- ---- --- -- - -  -   -
 
-    template <class Function> 
-    class unfused<Function,true>
-      : public unfused<Function,false>
+    template <class Derived, template<typename> class Result> 
+    class unfuse_interface<Derived,Result,true>
+      : public unfuse_interface<Derived,Result,false>
     {
-        typedef typename detail::qf_c<Function>::type function_c;
-        typedef typename detail::qf<Function>::type function;
-        typedef typename detail::call_param<Function>::type func_const_fwd_t;
       public:
+        using unfuse_interface<Derived,Result,false>::operator();
 
-        using unfused<Function,false>::operator();
+        template<typename Sig>
+        struct result
+            : unfuse_interface<Derived,Result,false>::result<Sig>{};
 
-        inline explicit unfused(func_const_fwd_t f = function())
-            : unfused<Function,false>(f)
-        { }
+        template<typename Self>
+        struct result<Self()>
+            : Result<Derived (fusion::vector0<> &)>{};
 
-        typedef typename boost::result_of<
-            function_c(fusion::vector0<> &) >::type call_const_0_result;
+        template<typename Self>
+        struct result<Self const ()>
+            : Result<Derived const (fusion::vector0<> &)>{};
 
-        inline call_const_0_result operator()() const
+        inline typename result<Derived const ()>::type operator()() const
         {
             fusion::vector0<> arg;
-            return this->fnc_transformed(arg);
+            return static_cast<Derived const *>(this)->call(arg);
         }
 
-        typedef typename boost::result_of< 
-            function(fusion::vector0<> &) >::type call_0_result;
-
-        inline call_0_result operator()() 
+        inline typename result<Derived ()>::type operator()() 
         {
             fusion::vector0<> arg;
-            return this->fnc_transformed(arg);
+            return static_cast<Derived *>(this)->call(arg);
         }
     };
 
-    template <class Function> class unfused<Function,false>
+    template <class Derived, template<typename> class Result>
+    class unfuse_interface<Derived, Result,false>
     {
-      protected:
-        Function fnc_transformed;
-        typedef typename detail::qf_c<Function>::type function_c;
-        typedef typename detail::qf<Function>::type function;
-        typedef typename detail::call_param<Function>::type func_const_fwd_t;
       public:
-
-        inline explicit unfused(func_const_fwd_t f = function())
-            : fnc_transformed(f)
-        { }
-
         template <typename Sig>
         struct result;
 
@@ -91,27 +80,85 @@
         #define  BOOST_PP_ITERATION_LIMITS \
             (1,BOOST_FUSION_UNFUSED_MAX_ARITY)
         #include BOOST_PP_ITERATE()
+
+        //perfect forwarding for up to 2 arguments:
+        template <typename T0,typename T1>
+        inline typename result< Derived const (T0 const &,T1 &) >::type
+        operator()(T0 const &a0,T1 &a1) const{
+            fusion::vector2<T0 const &,T1 &> arg(a0,a1);
+            return static_cast<Derived const *>(this)->call(arg);
+        }
+        template <typename T0,typename T1>
+        inline typename result< Derived const (T0 const &,T1 &) >::type
+        operator()(T0 const &a0,T1 &a1){
+            fusion::vector2<T0 const &,T1 &> arg(a0,a1);
+            return static_cast<Derived *>(this)->call(arg);
+        }
+        template <typename T0,typename T1>
+        inline typename result< Derived const (T0 &,T1 const &) >::type
+        operator()(T0 &a0,T1 const &a1) const{
+            fusion::vector2<T0 &,T1 const &> arg(a0,a1);
+            return static_cast<Derived const *>(this)->call(arg);
+        }
+        template <typename T0,typename T1>
+        inline typename result< Derived const (T0 &,T1 const &) >::type
+        operator()(T0 &a0,T1 const &a1){
+            fusion::vector2<T0 &,T1 const &> arg(a0,a1);
+            return static_cast<Derived *>(this)->call(arg);
+        }
     };
+
+    namespace detail{
+    
+        template<typename Function>
+        struct fused_result{
+            typedef typename detail::qf_c<Function>::type function_c;
+            typedef typename detail::qf<Function>::type function;
+            template<typename Sig>
+            struct result;
+            template<typename Self,typename Seq>
+            struct result<Self const (Seq &)>
+                : boost::result_of< function_c (Seq &) >{};
+            template<typename Self,typename Seq>
+            struct result<Self (Seq &)>
+                : boost::result_of< function (Seq &) >{};
+        };
+    }
+
+    template <class Function, bool AllowNullary = true>
+    class unfused
+        : public unfuse_interface<
+            unfused<Function,AllowNullary>,
+            typename detail::fused_result<Function>::template result,
+            AllowNullary>{
+        typedef typename detail::call_param<Function>::type func_const_fwd_t;
+    public:
+        inline explicit unfused(func_const_fwd_t f = function())
+            : fnc_transformed(f)
+        { }
+    private:
+        Function fnc_transformed;
+        template<class,template<typename> class,bool>
+        friend class unfuse_interface;
+        template<typename Seq>
+        typename detail::fused_result<Function>::template result<unfused (Seq &)>::type
+        call(Seq &seq){
+            return fnc_transformed(seq);
+        }
+        template<typename Seq>
+        typename detail::fused_result<Function>::template result<unfused const (Seq &)>::type
+        call(Seq &seq) const{
+            return fnc_transformed(seq);
+        }
+
+    };
+
 }}
 
 #if defined (BOOST_MSVC)
 #  pragma warning(pop)
 #endif
 
-namespace boost 
-{
-    template<class F>
-    struct result_of< boost::fusion::unfused<F> const () >
-    {
-        typedef typename boost::fusion::unfused<F>::call_const_0_result type;
-    };
-    template<class F>
-    struct result_of< boost::fusion::unfused<F>() >
-    {
-        typedef typename boost::fusion::unfused<F>::call_0_result type;
-    };
-}
-
 #define BOOST_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_HPP_INCLUDED
 #else // defined(BOOST_PP_IS_ITERATING)
 ////////////////////////////////////////////////////////////////////////////////
@@ -122,40 +169,55 @@
 #define N BOOST_PP_ITERATION()
 
         template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
-        struct result< Self const (BOOST_PP_ENUM_PARAMS(N,T)) >
-            : boost::result_of< function_c(
+        struct result< Self (BOOST_PP_ENUM_PARAMS(N,T)) >
+            : Result< Self (
                 BOOST_PP_CAT(fusion::vector,N)< BOOST_PP_ENUM_BINARY_PARAMS(N,
                     typename detail::mref<T,>::type BOOST_PP_INTERCEPT) > & )>
         { };
 
-        template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
-        struct result< Self(BOOST_PP_ENUM_PARAMS(N,T)) >
-            : boost::result_of< function(
-                BOOST_PP_CAT(fusion::vector,N)< BOOST_PP_ENUM_BINARY_PARAMS(N,
-                    typename detail::mref<T,>::type BOOST_PP_INTERCEPT) > & )>
-        { };
-
+        //const interface, non-const arguments
         template <BOOST_PP_ENUM_PARAMS(N,typename T)>
-        inline typename boost::result_of<function_c(BOOST_PP_CAT(fusion::vector,N)
-            <BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)> & )>::type
+        inline typename result< Derived const (BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)) >::type
         operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
         {
             BOOST_PP_CAT(fusion::vector,N)<
                   BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT) >
-                arg(BOOST_PP_ENUM_PARAMS(N,a));
-            return this->fnc_transformed(arg);
+                arg(BOOST_PP_ENUM_PARAMS(N,a)); 
+            return static_cast<Derived const *>(this)->call(arg);
         }
 
+        //non-const interface, non-const arguments
         template <BOOST_PP_ENUM_PARAMS(N,typename T)>
-        inline typename boost::result_of<function(BOOST_PP_CAT(fusion::vector,N)
-            <BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)> & )>::type
+        inline typename result< Derived (BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)) >::type
         operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) 
         {
             BOOST_PP_CAT(fusion::vector,N)<
                   BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT) >
                 arg(BOOST_PP_ENUM_PARAMS(N,a));
-            return this->fnc_transformed(arg);
+            return static_cast<Derived *>(this)->call(arg);
         }
+
+        //const interface, const arguments
+        template <BOOST_PP_ENUM_PARAMS(N,typename T)>
+        inline typename result< Derived const (BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & BOOST_PP_INTERCEPT)) >::type
+        operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & a)) const
+        {
+            BOOST_PP_CAT(fusion::vector,N)<
+                  BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & BOOST_PP_INTERCEPT) >
+                arg(BOOST_PP_ENUM_PARAMS(N,a)); 
+            return static_cast<Derived const *>(this)->call(arg);
+        }
+
+        //non-const interface, const arguments
+        template <BOOST_PP_ENUM_PARAMS(N,typename T)>
+        inline typename result< Derived (BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & BOOST_PP_INTERCEPT)) >::type
+        operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & a)) 
+        {
+            BOOST_PP_CAT(fusion::vector,N)<
+                  BOOST_PP_ENUM_BINARY_PARAMS(N,T,const & BOOST_PP_INTERCEPT) >
+                arg(BOOST_PP_ENUM_PARAMS(N,a));
+            return static_cast<Derived *>(this)->call(arg);
+        }
 #undef N
 #endif // defined(BOOST_PP_IS_ITERATING)
 #endif