X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=boost%2Fboost%2Fbind.hpp;h=6979fecd0576d99747a78e4c3b2b61b3482102bc;hb=b01a9dc187d9cd396a57463ad27511379dcdc9cd;hp=5480d1f2f8f9aa613c9b97afffa5474ea0619482;hpb=69862d12f457dd5dbf509c4d46a0399d4b16cfc7;p=lyx.git

diff --git a/boost/boost/bind.hpp b/boost/boost/bind.hpp
index 5480d1f2f8..6979fecd05 100644
--- a/boost/boost/bind.hpp
+++ b/boost/boost/bind.hpp
@@ -1,20 +1,22 @@
 #ifndef BOOST_BIND_HPP_INCLUDED
 #define BOOST_BIND_HPP_INCLUDED
 
-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 //
 //  bind.hpp - binds function objects to arguments
 //
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2001 David Abrahams
+//  Copyright (c) 2005 Peter Dimov
 //
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+// 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)
 //
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //
@@ -22,7 +24,10 @@
 #include <boost/config.hpp>
 #include <boost/ref.hpp>
 #include <boost/mem_fn.hpp>
+#include <boost/type.hpp>
 #include <boost/bind/arg.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/visit_each.hpp>
 
 // Borland-specific bug, visit_each() silently fails to produce code
 
@@ -32,6 +37,8 @@
 #  define BOOST_BIND_VISIT_EACH visit_each
 #endif
 
+#include <boost/bind/storage.hpp>
+
 #ifdef BOOST_MSVC
 # pragma warning(push)
 # pragma warning(disable: 4512) // assignment operator could not be generated
@@ -66,6 +73,28 @@ template<class F> struct result_traits< unspecified, reference_wrapper<F> >
 
 #endif
 
+// ref_compare
+
+template<class T> bool ref_compare( T const & a, T const & b, long )
+{
+    return a == b;
+}
+
+template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
+{
+    return true;
+}
+
+template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
+{
+    return true;
+}
+
+template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
+{
+    return a.get_pointer() == b.get_pointer();
+}
+
 // bind_t forward declaration for listN
 
 template<class R, class F, class L> class bind_t;
@@ -81,6 +110,11 @@ public:
     T & get() { return t_; }
     T const & get() const { return t_; }
 
+    bool operator==(value const & rhs) const
+    {
+        return t_ == rhs.t_;
+    }
+
 private:
 
     T t_;
@@ -92,47 +126,35 @@ template<class T> class type {};
 
 // unwrap
 
-template<class F> inline F & unwrap(F & f, long)
+template<class F> struct unwrapper
 {
-    return f;
-}
+    static inline F & unwrap( F & f, long )
+    {
+        return f;
+    }
 
-template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
-{
-    return f;
-}
+    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
+    {
+        return rf.get();
+    }
 
-template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
-{
-    return f;
-}
+    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
+    {
+        return _mfi::dm<R, T>( pm );
+    }
+};
 
 // listN
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-template <class R> struct evaluator0;
-template <class R> struct evaluator1;
-template <class R> struct evaluator2;
-template <class R> struct evaluator3;
-template <class R> struct evaluator4;
-template <class R> struct evaluator5;
-template <class R> struct evaluator6;
-template <class R> struct evaluator7;
-template <class R> struct evaluator8;
-template <class R> struct evaluator9;
-
-#endif
-
 class list0
 {
 public:
 
     list0() {}
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -140,39 +162,53 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A &) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
     {
-        return unwrap(f, 0)();
+        return unwrapper<F>::unwrap(f, 0)();
     }
 
-    template<class V> void accept(V &) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
     {
+        return unwrapper<F const>::unwrap(f, 0)();
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
+    template<class F, class A> void operator()(type<void>, F & f, A &, int)
+    {
+        unwrapper<F>::unwrap(f, 0)();
+    }
 
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
     {
-        typedef evaluator0<R> type;
-    };
+        unwrapper<F const>::unwrap(f, 0)();
+    }
 
-#endif
+    template<class V> void accept(V &) const
+    {
+    }
 
+    bool operator==(list0 const &) const
+    {
+        return true;
+    }
 };
 
-template<class A1> class list1
+template< class A1 > class list1: private storage1< A1 >
 {
+private:
+
+    typedef storage1< A1 > base_type;
+
 public:
 
-    explicit list1(A1 a1): a1_(a1) {}
+    explicit list1( A1 a1 ): base_type( a1 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -180,99 +216,56 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator1<R> type;
-    };
-
-#else
-
-private:
-
-#endif
-
-    A1 a1_;
-};
-
-template<class A1, class A2> class list2
-{
-public:
-
-    list2(A1 a1, A2 a2): a1_(a1), a2_(a2) {}
-
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
-
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
-
-    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
-
-    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+    }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        return unwrap(f, 0)(a[a1_], a[a2_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
+        base_type::accept(v);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    bool operator==(list1 const & rhs) const
     {
-        typedef evaluator2<R> type;
-    };
-
-#else
+        return ref_compare(base_type::a1_, rhs.a1_, 0);
+    }
+};
 
+template< class A1, class A2 > class list2: private storage2< A1, A2 >
+{
 private:
 
-#endif
-
-    A1 a1_;
-    A2 a2_;
-};
+    typedef storage2< A1, A2 > base_type;
 
-template<class A1, class A2, class A3> class list3
-{
 public:
 
-    list3(A1 a1, A2 a2, A3 a3): a1_(a1), a2_(a2), a3_(a3) {}
+    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -280,55 +273,58 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator3<R> type;
-    };
-
-#else
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
 
-private:
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
 
-#endif
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
+    bool operator==(list2 const & rhs) const
+    {
+        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
+    }
 };
 
-template<class A1, class A2, class A3, class A4> class list4
+template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
 {
+private:
+
+    typedef storage3< A1, A2, A3 > base_type;
+
 public:
 
-    list4(A1 a1, A2 a2, A3 a3, A4 a4): a1_(a1), a2_(a2), a3_(a3), a4_(a4) {}
+    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -336,59 +332,64 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator4<R> type;
-    };
-
-#else
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
 
-private:
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
 
-#endif
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
+    bool operator==(list3 const & rhs) const
+    {
+        return
+            
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 );
+    }
 };
 
-template<class A1, class A2, class A3, class A4, class A5> class list5
+template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
 {
+private:
+
+    typedef storage4< A1, A2, A3, A4 > base_type;
+
 public:
 
-    list5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5) {}
+    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
-    A5 operator[] (arg<5>) const { return a5_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (arg<5> (*) ()) const { return a5_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -396,63 +397,67 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator5<R> type;
-    };
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
 
-#else
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
 
-private:
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-#endif
+    bool operator==(list4 const & rhs) const
+    {
+        return
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 );
+    }
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6> class list6
+template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
 {
+private:
+
+    typedef storage5< A1, A2, A3, A4, A5 > base_type;
+
 public:
 
-    list6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6) {}
+    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
-    A5 operator[] (arg<5>) const { return a5_; }
-    A6 operator[] (arg<6>) const { return a6_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (arg<6> (*) ()) const { return a6_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -460,67 +465,70 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator6<R> type;
-    };
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
 
-#else
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
 
-private:
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-#endif
+    bool operator==(list5 const & rhs) const
+    {
+        return
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 );
+    }
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7
+template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
 {
+private:
+
+    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
+
 public:
 
-    list7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7) {}
+    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
-    A5 operator[] (arg<5>) const { return a5_; }
-    A6 operator[] (arg<6>) const { return a6_; }
-    A7 operator[] (arg<7>) const { return a7_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (arg<7> (*) ()) const { return a7_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -528,71 +536,73 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator7<R> type;
-    };
-
-#else
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
 
-private:
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
 
-#endif
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
+    bool operator==(list6 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 );
+    }
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class list8
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
 {
+private:
+
+    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
+
 public:
 
-    list8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8) {}
+    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
-    A5 operator[] (arg<5>) const { return a5_; }
-    A6 operator[] (arg<6>) const { return a6_; }
-    A7 operator[] (arg<7>) const { return a7_; }
-    A8 operator[] (arg<8>) const { return a8_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (arg<7> (*) ()) const { return a7_; }
-    A8 operator[] (arg<8> (*) ()) const { return a8_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -600,75 +610,76 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
-        BOOST_BIND_VISIT_EACH(v, a8_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator8<R> type;
-    };
-
-#else
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
 
-private:
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
 
-#endif
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
 
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
-    A8 a8_;
+    bool operator==(list7 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 );
+    }
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
 {
+private:
+
+    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
+
 public:
 
-    list9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9) {}
+    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
 
-    A1 operator[] (arg<1>) const { return a1_; }
-    A2 operator[] (arg<2>) const { return a2_; }
-    A3 operator[] (arg<3>) const { return a3_; }
-    A4 operator[] (arg<4>) const { return a4_; }
-    A5 operator[] (arg<5>) const { return a5_; }
-    A6 operator[] (arg<6>) const { return a6_; }
-    A7 operator[] (arg<7>) const { return a7_; }
-    A8 operator[] (arg<8>) const { return a8_; }
-    A9 operator[] (arg<9>) const { return a9_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
 
-    A1 operator[] (arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (arg<7> (*) ()) const { return a7_; }
-    A8 operator[] (arg<8> (*) ()) const { return a8_; }
-    A9 operator[] (arg<9> (*) ()) const { return a9_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
 
-    template<class T> T & operator[] (value<T> & v) const { return v.get(); }
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-    template<class T> T const & operator[] (value<T> const & v) const { return v.get(); }
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
@@ -676,232 +687,127 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
-    template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
-    template<class V> void accept(V & v) const
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
-        BOOST_BIND_VISIT_EACH(v, a8_, 0);
-        BOOST_BIND_VISIT_EACH(v, a9_, 0);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
-#ifdef BOOST_NO_VOID_RETURNS
-
-    template<class R> struct evaluator
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        typedef evaluator9<R> type;
-    };
-
-#else
-
-private:
-
-#endif
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
-    A8 a8_;
-    A9 a9_;
-};
-
-#ifdef BOOST_NO_VOID_RETURNS
-
-template <class R> struct evaluator0
-{
-    template<class L, class F, class A>
-    static R eval(L const&, F f, A &)
-    {
-        return unwrap(f, 0)();
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
-};
 
-template <> struct evaluator0<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const&, F f, A &)
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrap(f, 0)();
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
-};
 
-template <class R> struct evaluator1
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    template<class V> void accept(V & v) const
     {
-        return unwrap(f, 0)(a[l.a1_]);
+        base_type::accept(v);
     }
-};
 
-template <> struct evaluator1<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    bool operator==(list8 const & rhs) const
     {
-        unwrap(f, 0)(a[l.a1_]);
+        return
+            
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 );
     }
 };
 
-template <class R> struct evaluator2
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
 {
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
-    }
-};
+private:
 
-template <> struct evaluator2<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_]);
-    }
-};
+    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
 
-template <class R> struct evaluator3
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
-    }
-};
+public:
 
-template <> struct evaluator3<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
-    }
-};
+    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
 
-template <class R> struct evaluator4
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
-    }
-};
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
 
-template <> struct evaluator4<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
-    }
-};
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
 
-template <class R> struct evaluator5
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
-    }
-};
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
-template <> struct evaluator5<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
-    }
-};
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 
-template <class R> struct evaluator6
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
-    {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
-    }
-};
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 
-template <> struct evaluator6<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
-    {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
-    }
-};
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
 
-template <class R> struct evaluator7
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
-};
 
-template <> struct evaluator7<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
-};
 
-template <class R> struct evaluator8
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
-};
 
-template <> struct evaluator8<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
-};
 
-template <class R> struct evaluator9
-{
-    template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    template<class V> void accept(V & v) const
     {
-        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+        base_type::accept(v);
     }
-};
 
-template <> struct evaluator9<void>
-{
-    template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    bool operator==(list9 const & rhs) const
     {
-        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
+            ref_compare( base_type::a9_, rhs.a9_, 0 );
     }
 };
 
-#endif
-
 // bind_t
 
 #ifndef BOOST_NO_VOID_RETURNS
@@ -910,11 +816,13 @@ template<class R, class F, class L> class bind_t
 {
 public:
 
+    typedef bind_t this_type;
+
     bind_t(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_EVALUATE return l_(type<result_type>(), f_, a)
+#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN
 
 };
 
@@ -927,11 +835,13 @@ template<class F, class L> class implementation
 {
 public:
 
+    typedef implementation this_type;
+
     implementation(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_EVALUATE return L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
+#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN
 
 };
 
@@ -948,11 +858,13 @@ private:
 
 public:
 
+    typedef implementation this_type;
+
     implementation(F f, L const & l): f_(f), l_(l) {}
 
-#define BOOST_BIND_EVALUATE L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
+#define BOOST_BIND_RETURN
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_EVALUATE
+#undef BOOST_BIND_RETURN
 
 };
 
@@ -968,18 +880,67 @@ public:
 
 #endif
 
+// function_equal
+
+#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+
+// put overloads in _bi, rely on ADL
+
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
+{
+    return a.compare(b);
+}
+
+# else
+
+template<class R, class F, class L> bool function_equal_impl( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
+{
+    return a.compare(b);
+}
+
+# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+
+// put overloads in boost
+
+} // namespace _bi
+
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )
+{
+    return a.compare(b);
+}
+
+# else
+
+template<class R, class F, class L> bool function_equal_impl( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b, int )
+{
+    return a.compare(b);
+}
+
+# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+namespace _bi
+{
+
+#endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+
 // add_value
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
 
 template<class T> struct add_value
 {
-    typedef value<T> type;
+    typedef _bi::value<T> type;
 };
 
 template<class T> struct add_value< value<T> >
 {
-    typedef value<T> type;
+    typedef _bi::value<T> type;
 };
 
 template<class T> struct add_value< reference_wrapper<T> >
@@ -989,12 +950,12 @@ template<class T> struct add_value< reference_wrapper<T> >
 
 template<int I> struct add_value< arg<I> >
 {
-    typedef arg<I> type;
+    typedef boost::arg<I> type;
 };
 
 template<int I> struct add_value< arg<I> (*) () >
 {
-    typedef arg<I> (*type) ();
+    typedef boost::arg<I> (*type) ();
 };
 
 template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
@@ -1133,20 +1094,108 @@ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, c
     typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
 };
 
+// operator!
+
+struct logical_not
+{
+    template<class V> bool operator()(V const & v) const { return !v; }
+};
+
+template<class R, class F, class L>
+    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
+    operator! (bind_t<R, F, L> const & f)
+{
+    typedef list1< bind_t<R, F, L> > list_type;
+    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
+}
+
+// relational operators
+
+#define BOOST_BIND_OPERATOR( op, name ) \
+\
+struct name \
+{ \
+    template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
+}; \
+ \
+template<class R, class F, class L, class A2> \
+    bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
+    operator op (bind_t<R, F, L> const & f, A2 a2) \
+{ \
+    typedef typename add_value<A2>::type B2; \
+    typedef list2< bind_t<R, F, L>, B2> list_type; \
+    return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
+}
+
+BOOST_BIND_OPERATOR( ==, equal )
+BOOST_BIND_OPERATOR( !=, not_equal )
+
+BOOST_BIND_OPERATOR( <, less )
+BOOST_BIND_OPERATOR( <=, less_equal )
+
+BOOST_BIND_OPERATOR( >, greater )
+BOOST_BIND_OPERATOR( >=, greater_equal )
+
+#undef BOOST_BIND_OPERATOR
+
+#if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
+
+// resolve ambiguity with rel_ops
+
+#define BOOST_BIND_OPERATOR( op, name ) \
+\
+template<class R, class F, class L> \
+    bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
+    operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
+{ \
+    typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
+    return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
+}
+
+BOOST_BIND_OPERATOR( !=, not_equal )
+BOOST_BIND_OPERATOR( <=, less_equal )
+BOOST_BIND_OPERATOR( >, greater )
+BOOST_BIND_OPERATOR( >=, greater_equal )
+
+#endif
+
+// visit_each, ADL
+
+#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
+   && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+
+template<class V, class T> void visit_each( V & v, value<T> const & t, int )
+{
+    using boost::visit_each;
+    BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
+}
+
+template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
+{
+    t.accept( v );
+}
+
+#endif
+
 } // namespace _bi
 
-// visit_each
+// visit_each, no ADL
+
+#if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
+  || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
 
-template<class V, class T> void visit_each(V & v, _bi::value<T> const & t, int)
+template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
 {
-    BOOST_BIND_VISIT_EACH(v, t.get(), 0);
+    BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
 }
 
-template<class V, class R, class F, class L> void visit_each(V & v, _bi::bind_t<R, F, L> const & t, int)
+template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
 {
-    t.accept(v);
+    t.accept( v );
 }
 
+#endif
+
 // bind
 
 #ifndef BOOST_BIND
@@ -1235,6 +1284,88 @@ template<class R, class F, class A1, class A2, class A3, class A4, class A5, cla
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
 
+// generic function objects, alternative syntax
+
+template<class R, class F>
+    _bi::bind_t<R, F, _bi::list0>
+    BOOST_BIND(boost::type<R>, F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class F, class A1>
+    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class F, class A1, class A2>
+    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R, class F, class A1, class A2, class A3>
+    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 
 // adaptable function objects
@@ -1377,6 +1508,18 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 #undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
 
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_BIND_MF_NAME(X) X##_cdecl
+#define BOOST_BIND_MF_CC __cdecl
+
+#include <boost/bind/bind_mf_cc.hpp>
+
+#undef BOOST_BIND_MF_NAME
+#undef BOOST_BIND_MF_CC
+
+#endif
+
 #ifdef BOOST_MEM_FN_ENABLE_STDCALL
 
 #define BOOST_BIND_MF_NAME(X) X##_stdcall
@@ -1403,15 +1546,95 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 // data member pointers
 
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
+    || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x600 ) )
+
 template<class R, class T, class A1>
-    _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
+_bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
     BOOST_BIND(R T::*f, A1 a1)
 {
     typedef _mfi::dm<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+    return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
 }
 
+#else
+
+namespace _bi
+{
+
+template< class Pm, int I > struct add_cref;
+
+template< class M, class T > struct add_cref< M T::*, 0 >
+{
+    typedef M type;
+};
+
+template< class M, class T > struct add_cref< M T::*, 1 >
+{
+    typedef M const & type;
+};
+
+template< class R, class T > struct add_cref< R (T::*) (), 1 >
+{
+    typedef void type;
+};
+
+#if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )
+
+template< class R, class T > struct add_cref< R (T::*) () const, 1 >
+{
+    typedef void type;
+};
+
+#endif // __IBMCPP__
+
+template<class R> struct isref
+{
+    enum value_type { value = 0 };
+};
+
+template<class R> struct isref< R& >
+{
+    enum value_type { value = 1 };
+};
+
+template<class R> struct isref< R* >
+{
+    enum value_type { value = 1 };
+};
+
+template<class Pm, class A1> struct dm_result
+{
+    typedef typename add_cref< Pm, 1 >::type type;
+};
+
+template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
+{
+    typedef typename bind_t<R, F, L>::result_type result_type;
+    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
+};
+
+} // namespace _bi
+
+template< class A1, class M, class T >
+
+_bi::bind_t<
+    typename _bi::dm_result< M T::*, A1 >::type,
+    _mfi::dm<M, T>,
+    typename _bi::list_av_1<A1>::type
+>
+
+BOOST_BIND( M T::*f, A1 a1 )
+{
+    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
+    typedef _mfi::dm<M, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
+}
+
+#endif
+
 } // namespace boost
 
 #ifndef BOOST_BIND_NO_PLACEHOLDERS