diff --git a/example/fast_mem_fn.hpp b/example/fast_mem_fn.hpp
new file mode 100644
index 0000000..2587c18
--- /dev/null
+++ b/example/fast_mem_fn.hpp
@@ -0,0 +1,248 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+//
+// This example implements a very efficient, generic member function wrapper.
+//
+//
+// Detailed description
+// ====================
+//
+// For most platforms C++ runs on (maybe all hardware platforms, as opposed to
+// virtual machines) there are indirect calls that take more time to execute 
+// than direct ones. Further calling a function usually takes more time than 
+// inlining it at the call site.
+//
+// A direct call is a machine instruction that calls a subroutine at a known
+// address encoded in the instruction itself. C++ compilers usually emit one of
+// these instructions for each function call to a nonvirtual function (a call to
+// a virtual function requires either two direct calls or one indirect call).
+// An indirect call is a machine instruction that calls a subroutine at an 
+// address known at runtime. C++ compilers usually emit at least one of these 
+// instructions for a call through a callable builtin variable.
+//
+// It is possible to use callable scalars as non-type template arguments. This
+// way the compiler knows which function we want to call when generating the
+// code for the call site, so it may inline (if it decides to do so) or use a 
+// direct call instead of being forced to use a slow, indirect call.
+//
+// We define a functor class template that encodes the function to call in its
+// type via a non-type template argument. Its (inline declared) overloaded 
+// function call operator calls the function through that non-type template 
+// argument. In the best case we end up inlining the callee directly at the
+// point of the call.
+//
+// Decomposition of the wrapped member function's type is needed in order to 
+// implement argument forwarding (just using a templated call operator we would 
+// encounter what is known as "the forwarding problem" [Dimov1]). Further we
+// can eliminate unecessary copies for each by-value parameter by using a 
+// reference to its const qualified type for the corresponding parameter of the
+// wrapper's function call operator.
+//
+// Finally we provide a macro that does have similar semantics to the function 
+// template mem_fn of the Bind [2] library.
+// We can't use a function template and use a macro instead, because we use a
+// member function pointer that is a compile time constant. So we first have to
+// deduce the type and create a template that accepts this type as a non-type 
+// template argument, which is passed in in a second step. The macro hides this
+// lengthy expression from the user.
+//
+//
+// Limitations
+// ===========
+//
+// The "this-argument" must be specified as a reference.
+//
+//
+// Bibliography
+// ============
+//
+// [Dimov1] Dimov, P., Hinnant H., Abrahams, D. The Forwarding Problem
+//          http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
+//
+// [Dimov2] Dimov, P. Documentation of boost::mem_fn
+//          http://www.boost.org/libs/bind/mem_fn.html
+
+#ifndef BOOST_EXAMPLE_FAST_MEM_FN_HPP_INCLUDED
+#ifndef BOOST_PP_IS_ITERATING
+
+
+#include <boost/function_types/result_type.hpp>
+#include <boost/function_types/function_arity.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/is_member_function_pointer.hpp>
+
+#include <boost/mpl/transform_view.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+
+#include <boost/utility/enable_if.hpp>
+
+#include "detail/param_type.hpp"
+
+namespace example
+{
+
+  namespace ft = boost::function_types;
+  namespace mpl = boost::mpl;
+  using namespace mpl::placeholders;
+
+  // the functor class template
+  template< typename MFPT, MFPT MemberFunction
+    , size_t Arity = ::example::ft::function_arity<MFPT>::value
+  >
+  struct fast_mem_fn;
+
+  // ------- ---- --- -- - - - -
+
+  // deduce type and capture compile time value 
+  #define BOOST_EXAMPLE_FAST_MEM_FN(mfp) \
+      ::example::make_fast_mem_fn(mfp).make_fast_mem_fn<mfp>()
+
+  template<typename MFPT>
+  struct fast_mem_fn_maker
+  {
+    template<MFPT Callee>
+    fast_mem_fn<MFPT,Callee> make_fast_mem_fn()
+    {
+      return fast_mem_fn<MFPT,Callee>();
+    } 
+  };
+
+  template<typename MFPT>
+      typename boost::enable_if<boost::is_member_function_pointer<MFPT>, 
+  fast_mem_fn_maker<MFPT>                                                >::type
+  make_fast_mem_fn(MFPT)
+  {
+    return fast_mem_fn_maker<MFPT>();
+  }
+
+
+  // ------- ---- --- -- - - - -
+
+  namespace detail
+  {
+    // by-value forwarding optimization
+    template<typename T>
+    struct parameter_types
+      : mpl::transform_view<ft::parameter_types<T>,param_type<_> >
+    { }; 
+  }
+
+  // ------- ---- --- -- - - - -
+
+  template< typename MFPT, MFPT MemberFunction >
+  struct fast_mem_fn<MFPT, MemberFunction, 1>
+  {
+    // decompose the result and the parameter types (public for introspection)
+    typedef typename ft::result_type<MFPT>::type result_type;
+    typedef detail::parameter_types<MFPT> parameter_types;
+  private:
+    // iterate the parameter types 
+    typedef typename mpl::begin<parameter_types>::type i0;
+  public: 
+    // forwarding function call operator
+    result_type operator()( typename mpl::deref<i0>::type a0) const
+    {
+      return (a0.*MemberFunction)();
+    };
+  };
+
+  template< typename MFPT, MFPT MemberFunction >
+  struct fast_mem_fn<MFPT, MemberFunction, 2>
+  {
+    // decompose the result and the parameter types (public for introspection)
+    typedef typename ft::result_type<MFPT>::type result_type;
+    typedef detail::parameter_types<MFPT> parameter_types;
+  private:
+    // iterate the parameter types 
+    typedef typename mpl::begin<parameter_types>::type i0;
+    typedef typename mpl::next<i0>::type i1;
+  public: 
+    // forwarding function call operator
+    result_type operator()( typename mpl::deref<i0>::type a0
+                          , typename mpl::deref<i1>::type a1) const
+    {
+      return (a0.*MemberFunction)(a1);
+    };
+  };
+
+  template< typename MFPT, MFPT MemberFunction >
+  struct fast_mem_fn<MFPT, MemberFunction, 3>
+  {
+    // decompose the result and the parameter types (public for introspection)
+    typedef typename ft::result_type<MFPT>::type result_type;
+    typedef detail::parameter_types<MFPT> parameter_types;
+  private:
+    // iterate the parameter types 
+    typedef typename mpl::begin<parameter_types>::type i0;
+    typedef typename mpl::next<i0>::type i1;
+    typedef typename mpl::next<i1>::type i2;
+  public: 
+    // forwarding function call operator
+    result_type operator()( typename mpl::deref<i0>::type a0
+                          , typename mpl::deref<i1>::type a1
+                          , typename mpl::deref<i2>::type a2) const
+    {
+      return (a0.*MemberFunction)(a1,a2);
+    };
+  };
+
+  // ...
+}
+
+// ------- ---- --- -- - - - -
+
+// preprocessor-based code generator to continue the repetitive part, above
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+namespace example
+{
+  #if BOOST_FT_MAX_ARITY >= 4
+  #   define  BOOST_PP_FILENAME_1 "fast_mem_fn.hpp"
+  #   define  BOOST_PP_ITERATION_LIMITS (4,BOOST_FT_MAX_ARITY)
+  #   include BOOST_PP_ITERATE()
+  #endif
+}
+
+#define BOOST_EXAMPLE_FAST_MEM_FN_HPP_INCLUDED
+#else
+
+  #define N BOOST_PP_FRAME_ITERATION(1)
+  template< typename MFPT, MFPT MemberFunction >
+  struct fast_mem_fn<MFPT, MemberFunction, N >
+  {
+    // decompose the result and the parameter types (public for introspection)
+    typedef typename ft::result_type<MFPT>::type result_type;
+    typedef detail::parameter_types<MFPT> parameter_types;
+  private:
+    // iterate the parameter types 
+    typedef typename mpl::begin<parameter_types>::type i0;
+    #define  BOOST_PP_LOCAL_LIMITS (0,N-2)
+    #define  BOOST_PP_LOCAL_MACRO(j) \
+    typedef typename mpl::next< i ## j >::type BOOST_PP_CAT(i,BOOST_PP_INC(j)) ;
+    #include BOOST_PP_LOCAL_ITERATE()
+  public: 
+    // forwarding function call operator
+    result_type operator()( 
+        BOOST_PP_ENUM_BINARY_PARAMS(N, typename mpl::deref<i,>::type a) )  const
+    {
+      return (a0.*MemberFunction)(BOOST_PP_ENUM_SHIFTED_PARAMS(N,a));
+    };
+  };
+  #undef N
+
+#endif
+#endif
+