From 5cef4e4f788e763ad3a9bedcecc58ca3e0241eb8 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Thu, 4 Jan 2024 19:51:50 +0200
Subject: [PATCH] Eliminate mem_fn_template.hpp

---
 include/boost/bind/bind_mf2_cc.hpp     | 108 +++------
 include/boost/bind/bind_mf_cc.hpp      | 324 ++++++++++---------------
 include/boost/bind/mem_fn.hpp          |  93 +++----
 include/boost/bind/mem_fn_cc.hpp       |  12 +-
 include/boost/bind/mem_fn_template.hpp | 119 ---------
 5 files changed, 218 insertions(+), 438 deletions(-)
 delete mode 100644 include/boost/bind/mem_fn_template.hpp

diff --git a/include/boost/bind/bind_mf2_cc.hpp b/include/boost/bind/bind_mf2_cc.hpp
index 3a2c97aa..2b660704 100644
--- a/include/boost/bind/bind_mf2_cc.hpp
+++ b/include/boost/bind/bind_mf2_cc.hpp
@@ -17,22 +17,18 @@
 
 template<class Rt2, class R, class T,
     class A1>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T>, typename _bi::list_av_1<A1>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1 );
 }
 
 template<class Rt2, class R, class T,
     class A1>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T>, typename _bi::list_av_1<A1>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1 );
 }
 
 // 1
@@ -40,23 +36,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2 );
 }
 
 template<class Rt2, class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2 );
 }
 
 // 2
@@ -64,23 +56,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3 );
 }
 
 // 3
@@ -88,23 +76,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 // 4
@@ -112,23 +96,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 // 5
@@ -136,23 +116,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 // 6
@@ -160,23 +136,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 // 7
@@ -184,23 +156,19 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 // 8
@@ -208,21 +176,17 @@ template<class Rt2, class R, class T,
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    auto
     BOOST_BIND(boost::type<Rt2>, R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND( boost::type<Rt2>(), boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
diff --git a/include/boost/bind/bind_mf_cc.hpp b/include/boost/bind/bind_mf_cc.hpp
index d98f9b61..00f24f40 100644
--- a/include/boost/bind/bind_mf_cc.hpp
+++ b/include/boost/bind/bind_mf_cc.hpp
@@ -16,44 +16,36 @@
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T>, typename _bi::list_av_1<A1>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<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 boost::BOOST_BIND( boost::mem_fn( f ), a1 );
 }
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T>, typename _bi::list_av_1<A1>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<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 boost::BOOST_BIND( boost::mem_fn( f ), a1 );
 }
 
 template<class Rt2, class R, class T,
-    class A1>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T>, typename _bi::list_av_1<A1>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
+    class A1,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 );
 }
 
 template<class Rt2, class R, class T,
-    class A1>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T>, typename _bi::list_av_1<A1>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
+    class A1,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 );
 }
 
 // 1
@@ -61,47 +53,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 );
 }
 
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 );
 }
 
 template<class Rt2, class R, class T,
     class B1,
-    class A1, class A2>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
+    class A1, class A2,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 );
 }
 
 template<class Rt2, class R, class T,
     class B1,
-    class A1, class A2>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
+    class A1, class A2,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 );
 }
 
 // 2
@@ -109,47 +93,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 );
 }
 
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2,
-    class A1, class A2, class A3>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
+    class A1, class A2, class A3,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2,
-    class A1, class A2, class A3>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
+    class A1, class A2, class A3,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 );
 }
 
 // 3
@@ -157,47 +133,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
+    class A1, class A2, class A3, class A4,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
+    class A1, class A2, class A3, class A4,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 );
 }
 
 // 4
@@ -205,47 +173,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    class A1, class A2, class A3, class A4, class A5,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    class A1, class A2, class A3, class A4, class A5,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
 }
 
 // 5
@@ -253,47 +213,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    class A1, class A2, class A3, class A4, class A5, class A6,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    class A1, class A2, class A3, class A4, class A5, class A6,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
 }
 
 // 6
@@ -301,47 +253,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
 }
 
 // 7
@@ -349,47 +293,39 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
 }
 
 // 8
@@ -397,45 +333,37 @@ template<class Rt2, class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
 
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    auto
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    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(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(mf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
 
 template<class Rt2, class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    typename boost::enable_if_c<!_bi::is_same<Rt2, R>::value,
-    _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
+    class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
+    auto
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::BOOST_BIND_MF_NAME(cmf)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+    return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 }
diff --git a/include/boost/bind/mem_fn.hpp b/include/boost/bind/mem_fn.hpp
index fa23f9b2..54266629 100644
--- a/include/boost/bind/mem_fn.hpp
+++ b/include/boost/bind/mem_fn.hpp
@@ -8,17 +8,16 @@
 #endif
 
 //
-//  mem_fn.hpp - a generalization of std::mem_fun[_ref]
+// mem_fn.hpp - a generalization of std::mem_fun[_ref]
 //
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2001 David Abrahams
-//  Copyright (c) 2003-2005 Peter Dimov
+// Copyright 2001-2005, 2024 Peter Dimov
+// Copyright 2001 David Abrahams
 //
 // 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/mem_fn.html for documentation.
+// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
 #include <boost/get_pointer.hpp>
@@ -36,54 +35,55 @@ template<class T> struct remove_cvref: std::remove_cv< typename std::remove_refe
 {
 };
 
-} // namespace _mfi
-
-namespace _mfi
+template<class Pm, class R, class T, class... A> class mf
 {
+public:
 
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
+    typedef R result_type;
 
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
+private:
 
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
+    Pm pm_;
 
-#include <boost/bind/mem_fn_template.hpp>
+public:
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+    mf( Pm pm ): pm_( pm ) {}
 
-#endif
+    template<class U,
+        class Ud = typename _mfi::remove_cvref<U>::type,
+        class En = typename std::enable_if<
+            std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value
+        >::type
+    >
 
-#if defined(BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
+    R operator()( U&& u, A... a ) const
+    {
+        return (std::forward<U>( u ).*pm_)( std::forward<A>( a )... );
+    }
 
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
+    template<class U,
+        class Ud = typename _mfi::remove_cvref<U>::type,
+        class E1 = void,
+        class En = typename std::enable_if<
+            !(std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value)
+        >::type
+    >
 
-#include <boost/bind/mem_fn_template.hpp>
+    R operator()( U&& u, A... a ) const
+    {
+        return (get_pointer( std::forward<U>( u ) )->*pm_)( std::forward<A>( a )... );
+    }
 
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
+    bool operator==( mf const & rhs ) const
+    {
+        return pm_ == rhs.pm_;
+    }
 
-#endif
+    bool operator!=( mf const & rhs ) const
+    {
+        return pm_ != rhs.pm_;
+    }
+};
 
 } // namespace _mfi
 
@@ -160,13 +160,13 @@ template<class R, class T> class dm
     typedef T const * argument_type;
 
 private:
-    
+
     typedef R (T::*Pm);
     Pm pm_;
 
 public:
 
-    explicit dm( Pm pm ): pm_( pm ) {}
+    dm( Pm pm ): pm_( pm ) {}
 
     template<class U,
         class Ud = typename _mfi::remove_cvref<U>::type,
@@ -222,9 +222,12 @@ template<class R, class T> class dm
 
 } // namespace _mfi
 
-template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
+template<class R, class T,
+    class E = typename std::enable_if< !std::is_function<R>::value >::type
+>
+_mfi::dm<R, T> mem_fn( R T::*pm )
 {
-    return _mfi::dm<R, T>(f);
+    return pm;
 }
 
 } // namespace boost
diff --git a/include/boost/bind/mem_fn_cc.hpp b/include/boost/bind/mem_fn_cc.hpp
index a1f006f9..58bdb4a7 100644
--- a/include/boost/bind/mem_fn_cc.hpp
+++ b/include/boost/bind/mem_fn_cc.hpp
@@ -12,12 +12,16 @@
 // See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-template<class R, class T, class... A> _mfi::BOOST_MEM_FN_NAME(mf)<R, T, A...> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A...) BOOST_MEM_FN_NOEXCEPT)
+template<class R, class T, class... A>
+_mfi::mf< R (BOOST_MEM_FN_CC T::*) (A...) BOOST_MEM_FN_NOEXCEPT, R, T, A... >
+mem_fn( R (BOOST_MEM_FN_CC T::*pmf) (A...) BOOST_MEM_FN_NOEXCEPT )
 {
-    return _mfi::BOOST_MEM_FN_NAME(mf)<R, T, A...>(f);
+    return pmf;
 }
 
-template<class R, class T, class... A> _mfi::BOOST_MEM_FN_NAME(cmf)<R, T, A...> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A...) const BOOST_MEM_FN_NOEXCEPT)
+template<class R, class T, class... A>
+_mfi::mf< R (BOOST_MEM_FN_CC T::*) (A...) const BOOST_MEM_FN_NOEXCEPT, R, T, A... >
+mem_fn( R (BOOST_MEM_FN_CC T::*pmf) (A...) const BOOST_MEM_FN_NOEXCEPT )
 {
-    return _mfi::BOOST_MEM_FN_NAME(cmf)<R, T, A...>(f);
+    return pmf;
 }
diff --git a/include/boost/bind/mem_fn_template.hpp b/include/boost/bind/mem_fn_template.hpp
deleted file mode 100644
index db0eebed..00000000
--- a/include/boost/bind/mem_fn_template.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// bind/mem_fn_template.hpp
-//
-// Do not include this header directly
-//
-// Copyright 2001, 2024 Peter Dimov
-//
-// 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/mem_fn.html for documentation.
-//
-
-// mf
-
-template<class R, class T, class... A> class BOOST_MEM_FN_NAME(mf)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    typedef R (BOOST_MEM_FN_CC T::*Pm) (A...);
-    Pm pm_;
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(mf)( Pm pm ): pm_( pm ) {}
-
-    template<class U,
-        class Ud = typename _mfi::remove_cvref<U>::type,
-        class En = typename std::enable_if<
-            std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value
-        >::type
-    >
-
-    R operator()( U&& u, A... a ) const
-    {
-        return (std::forward<U>( u ).*pm_)( std::forward<A>( a )... );
-    }
-
-    template<class U,
-        class Ud = typename _mfi::remove_cvref<U>::type,
-        class E1 = void,
-        class En = typename std::enable_if<
-            !(std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value)
-        >::type
-    >
-
-    R operator()( U&& u, A... a ) const
-    {
-        return (get_pointer( std::forward<U>( u ) )->*pm_)( std::forward<A>( a )... );
-    }
-
-    bool operator==( BOOST_MEM_FN_NAME(mf) const & rhs ) const
-    {
-        return pm_ == rhs.pm_;
-    }
-
-    bool operator!=( BOOST_MEM_FN_NAME(mf) const & rhs ) const
-    {
-        return pm_ != rhs.pm_;
-    }
-};
-
-// cmf
-
-template<class R, class T, class... A> class BOOST_MEM_FN_NAME(cmf)
-{
-public:
-
-    typedef R result_type;
-
-private:
-    
-    typedef R (BOOST_MEM_FN_CC T::*Pm) (A...) const;
-    Pm pm_;
-
-public:
-    
-    explicit BOOST_MEM_FN_NAME(cmf)( Pm pm ): pm_( pm ) {}
-
-    template<class U,
-        class Ud = typename _mfi::remove_cvref<U>::type,
-        class En = typename std::enable_if<
-            std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value
-        >::type
-    >
-
-    R operator()( U&& u, A... a ) const
-    {
-        return (std::forward<U>( u ).*pm_)( std::forward<A>( a )... );
-    }
-
-    template<class U,
-        class Ud = typename _mfi::remove_cvref<U>::type,
-        class E1 = void,
-        class En = typename std::enable_if<
-            !(std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value)
-        >::type
-    >
-
-    R operator()( U&& u, A... a ) const
-    {
-        return (get_pointer( std::forward<U>( u ) )->*pm_)( std::forward<A>( a )... );
-    }
-
-    bool operator==( BOOST_MEM_FN_NAME(cmf) const & rhs ) const
-    {
-        return pm_ == rhs.pm_;
-    }
-
-    bool operator!=( BOOST_MEM_FN_NAME(cmf) const & rhs ) const
-    {
-        return pm_ != rhs.pm_;
-    }
-};