Index: bind.hpp
===================================================================
--- bind.hpp	(revision 64741)
+++ bind.hpp	(working copy)
@@ -29,6 +29,7 @@
 #include <boost/bind/arg.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/visit_each.hpp>
+#include <boost/utility/result_of.hpp>
 
 // Borland-specific bug, visit_each() silently fails to produce code
 
@@ -272,6 +273,61 @@
 struct logical_and;
 struct logical_or;
 
+struct invalid{};
+
+template<class F,class L,class T,class Args>
+struct argresult;
+
+template<class F,class L,class T,class Args>
+struct argresult<F,L,value<T>,Args>{
+    typedef T type;
+};
+
+template<class F, class L,int I>
+struct argresult<F,L,boost::arg<I>,bind_t<unspecified,F,L>()>{
+    typedef invalid type;
+};
+
+template<class F, class L, class A1>
+struct argresult<F,L,boost::arg<1>,bind_t<unspecified,F,L>(A1)>{
+    typedef A1 type;
+};
+
+template<class F, class L, class A1>
+struct argresult<F,L,boost::arg<1>,bind_t<unspecified,F,L>(A1 &)>{
+    typedef A1 const &type;
+};
+
+template<class F, class L, class A1,class A2>
+struct argresult<F,L,boost::arg<1>,bind_t<unspecified,F,L>(A1,A2)>{
+    typedef A1 type;
+};
+
+template<class F, class L, class A1,class A2>
+struct argresult<F,L,boost::arg<1>,bind_t<unspecified,F,L>(A1 &,A2)>{
+    typedef A1 const &type;
+};
+
+template<class F, class A1, class A2>
+struct fresult2{
+    typedef typename boost::result_of<F(A1,A2)>::type type;
+};
+
+template<class F,class A1>
+struct fresult2<F,A1,invalid>{
+    typedef invalid type;
+};
+
+template<class F,class A2>
+struct fresult2<F,invalid,A2>{
+    typedef invalid type;
+};
+
+template<class F>
+struct fresult2<F,invalid,invalid>{
+    typedef invalid type;
+};
+
 template< class A1, class A2 > class list2: private storage2< A1, A2 >
 {
 private:
@@ -280,6 +336,15 @@
 
 public:
 
+    template<class R, class F, class Args>
+    struct bresult{
+        typedef typename fresult2<
+            F,
+            typename argresult<F,list2,A1,Args>::type,
+            typename argresult<F,list2,A2,Args>::type
+        >::type type;
+    };
+
     list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
 
     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
@@ -349,6 +414,7 @@
     }
 };
 
+
 template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
 {
 private:
@@ -861,6 +927,9 @@
 
 #ifndef BOOST_NO_VOID_RETURNS
 
+template<class R, class F, class L, class Args>
+struct bind_result;
+
 template<class R, class F, class L> class bind_t
 {
 public:
@@ -875,6 +944,7 @@
 
 };
 
+
 #else
 
 template<class R> struct bind_t_generator
Index: bind_template.hpp
===================================================================
--- bind_template.hpp	(revision 64741)
+++ bind_template.hpp	(working copy)
@@ -12,104 +12,107 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
 
-    typedef typename result_traits<R, F>::type result_type;
+    template<typename Args>
+    struct result{
+        typedef typename L::bresult<R,F,Args>::type type;
+    };
 
-    result_type operator()()
+    typename result<this_type()>::type operator()()
     {
         list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type()>::type>(), f_, a, 0);
     }
 
-    result_type operator()() const
+    typename result<this_type()>::type operator()() const
     {
         list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type()>::type>(), f_, a, 0);
     }
 
-    template<class A1> result_type operator()(A1 & a1)
+    template<class A1> typename result<this_type(A1 &)>::type operator()(A1 & a1)
     {
         list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &)>::type>(), f_, a, 0);
     }
 
-    template<class A1> result_type operator()(A1 & a1) const
+    template<class A1> typename result<this_type(A1 &)>::type operator()(A1 & a1) const
     {
         list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &)>::type>(), f_, a, 0);
     }
 
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
-    template<class A1> result_type operator()(A1 const & a1)
+    template<class A1> typename result<this_type(A1 const &)>::type operator()(A1 const & a1)
     {
         list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &)>::type>(), f_, a, 0);
     }
 
-    template<class A1> result_type operator()(A1 const & a1) const
+    template<class A1> typename result<this_type(A1 const &)>::type operator()(A1 const & a1) const
     {
         list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &)>::type>(), f_, a, 0);
     }
 
 #endif
 
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
+    template<class A1, class A2> typename result<this_type(A1 &,A2 &)>::type operator()(A1 & a1, A2 & a2)
     {
         list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &,A2 &)>::type>(), f_, a, 0);
     }
 
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
+    template<class A1, class A2> typename result<this_type(A1 &,A2 &)>::type operator()(A1 & a1, A2 & a2) const
     {
         list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &,A2 &)>::type>(), f_, a, 0);
     }
 
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
+    template<class A1, class A2> typename result<this_type(A1 const &,A2 &)>::type operator()(A1 const & a1, A2 & a2)
     {
         list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &,A2 &)>::type>(), f_, a, 0);
     }
 
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
+    template<class A1, class A2> typename result<this_type(A1 const &,A2 &)>::type operator()(A1 const & a1, A2 & a2) const
     {
         list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &,A2 &)>::type>(), f_, a, 0);
     }
 
 
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
+    template<class A1, class A2> typename result<this_type(A1 &,A2 const &)>::type operator()(A1 & a1, A2 const & a2)
     {
         list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &,A2 const &)>::type>(), f_, a, 0);
     }
 
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
+    template<class A1, class A2> typename result<this_type(A1 &,A2 const &)>::type operator()(A1 & a1, A2 const & a2) const
     {
         list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 &,A2 const &)>::type>(), f_, a, 0);
     }
 
 
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
+    template<class A1, class A2> typename result<this_type(A1 const &,A2 const &)>::type operator()(A1 const & a1, A2 const & a2)
     {
         list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &,A2 const &)>::type>(), f_, a, 0);
     }
 
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
+    template<class A1, class A2> typename result<this_type(A1 const &,A2 const &)>::type operator()(A1 const & a1, A2 const & a2) const
     {
         list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        BOOST_BIND_RETURN l_(type<typename result<this_type(A1 const &,A2 const &)>::type>(), f_, a, 0);
     }
 
 #endif
-
+#if 0
     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
     {
         list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
@@ -312,7 +315,8 @@
     }
 
 #endif
-
+#endif
+#if 0
     template<class A> result_type eval(A & a)
     {
         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
@@ -322,6 +326,7 @@
     {
         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
     }
+#endif
 
     template<class V> void accept(V & v) const
     {