#if !BOOST_PP_IS_ITERATING

    #ifndef CLOSURE_HPP
    #define CLOSURE_HPP "closure.hpp"

    #include <boost/preprocessor/facilities/apply.hpp>
    #include <boost/preprocessor/iteration/iterate.hpp>
    #include <boost/preprocessor/repetition/enum_binary_params.hpp>
    #include <boost/preprocessor/repetition/enum_params.hpp>
    #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
    #include <boost/preprocessor/seq/elem.hpp>

    #include <cassert>

    // identity

    template<class T> struct identity {
        typedef T type;
    };

    // enable_if

    template<bool, class R = void> struct enable_if { };
    template<class R> struct enable_if<true, R> : identity<R> { };

    // map_integral

    template<class T, T X> struct map_integral {
        static const T value = X;
    };

    template<class T, T X> const T map_integral<T, X>::value;

    // is_function

    template<class T> class is_function {
        private:
            template<class U> static char check(U (*)[1]);
            template<class U> static char (& check(...))[2];
        public:
            static const bool value = sizeof(check<T>(0)) != 1;
    };

    template<class T> const bool is_function<T>::value;

    template<> class is_function<void> : public map_integral<bool, false> { };
    template<class T> struct is_function<T&> : public map_integral<bool, true> {
};

    // closure

    namespace detail {

        template<class, class, class = void> class closure;
    
    }

    template<class T, class Ptr> class closure : public detail::closure<T, Ptr> { };

    #define cv(n) \
        BOOST_PP_APPLY(BOOST_PP_SEQ_ELEM( \
            n, (BOOST_PP_NIL)((const))((volatile))((const volatile)) \
        )) \
        /**/

    #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 3, CLOSURE_HPP))
    #include BOOST_PP_ITERATE()

    #undef cv

    template<class T, class D, class C> inline
    typename enable_if<
        !is_function<D>::value,
        typename closure<T, D C::*>::type
    >::type make_closure(T* obj, D C::* data) {
        assert(obj && data);
        return obj->*data;
    }

    template<class T, class D, class C> inline
    typename enable_if<
        is_function<D>::value,
        typename closure<T, D C::*>::type
    >::type make_closure(T* obj, D C::* func) {
        assert(obj && func);
        return typename closure<T, D C::*>::type(obj, func);
    }

    #endif

#elif BOOST_PP_ITERATION_DEPTH() == 1

    #define i BOOST_PP_FRAME_ITERATION(1)

    namespace detail {
        template<class T, class D, class C>
        class closure<cv(i) T, D C::*, typename enable_if<!is_function<D>::value>::type>
        : public identity<cv(i) D&> { };

    }

    #define BOOST_PP_ITERATION_PARAMS_2 \
        (3, (0, CLOSURE_MAX_ARITY ? CLOSURE_MAX_ARITY : 15, CLOSURE_HPP)) \
        /**/
    #include BOOST_PP_ITERATE()

    #undef i

#else

    #define j BOOST_PP_ITERATION()

    #define member(id) \
        R (C::* BOOST_PP_APPLY(id))(BOOST_PP_ENUM_PARAMS(j, P)) cv(i) \
        /**/

    template<class T, class R, class C BOOST_PP_ENUM_TRAILING_PARAMS(j, class P)>
    class closure<T, member(BOOST_PP_NIL)> {
        public:
            typedef closure type;
            inline closure(cv(i) C* obj, member((func)))
            : obj_((assert(obj), obj)), func_((assert(func), func)) {
                return;
            }
            inline R operator()(BOOST_PP_ENUM_BINARY_PARAMS(j, P, p)) const {
                return (obj_->*func_)(BOOST_PP_ENUM_PARAMS(j, p));
            }
        private:
            cv(i) C* obj_;
            member((func_));
    };

    #undef member
    #undef j

#endif