bind.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_BIND_HPP__
#define NEFORCE_CORE_FUNCTIONAL_BIND_HPP__

 
#include "NeForce/core/functional/invoke.hpp"
NEFORCE_BEGIN_NAMESPACE__

NEFORCE_BEGIN_INNER__
 
template <typename Res, typename... Args>
struct unary_or_binary_function {};
 
template <typename Res, typename T1>
struct unary_or_binary_function<Res, T1> : _NEFORCE unary_function<T1, Res> {};
 
template <typename Res, typename T1, typename T2>
struct unary_or_binary_function<Res, T1, T2> : _NEFORCE binary_function<T1, T2, Res> {};
 

template <typename Sign>
struct mem_func_traits;
 
template <typename Res, typename Class, typename... Args>
struct mem_func_traits_base {
    using result_type = Res;                                           
    using maybe_type = unary_or_binary_function<Res, Class*, Args...>; 
    using arity = integral_constant<size_t, sizeof...(Args)>;          
};
 
#define __NEFORCE_MEMFUNC_TRAITS_BASE(CV, REF)                                                                   \
    template <typename Res, typename Class, typename... Args>                                                    \
    struct mem_func_traits<Res (Class::*)(Args...) CV REF> : mem_func_traits_base<Res, CV Class, Args...> {      \
        using vararg = false_type;                                                                               \
    };                                                                                                           \
    template <typename Res, typename Class, typename... Args>                                                    \
    struct mem_func_traits<Res (Class::*)(Args..., ...) CV REF> : mem_func_traits_base<Res, CV Class, Args...> { \
        using vararg = true_type;                                                                                \
    };
 
#define __NEFORCE_MEMFUNC_TRAITS(REF, P)         \
    __NEFORCE_MEMFUNC_TRAITS_BASE(, REF)         \
    __NEFORCE_MEMFUNC_TRAITS_BASE(const, REF)    \
    __NEFORCE_MEMFUNC_TRAITS_BASE(volatile, REF) \
    __NEFORCE_MEMFUNC_TRAITS_BASE(const volatile, REF)
 
__NEFORCE_MEMFUNC_TRAITS(, )
__NEFORCE_MEMFUNC_TRAITS(&, )
__NEFORCE_MEMFUNC_TRAITS(&&, )
 
#ifdef NEFORCE_STANDARD_17
__NEFORCE_MEMFUNC_TRAITS(noexcept, )
__NEFORCE_MEMFUNC_TRAITS(& noexcept, )
__NEFORCE_MEMFUNC_TRAITS(&& noexcept, )
#endif
 
#undef __NEFORCE_MEMFUNC_TRAITS_BASE
#undef __NEFORCE_MEMFUNC_TRAITS
 
 
template <typename Func, typename = void_t<>>
struct maybe_get_result_type {};
 
template <typename Func>
struct maybe_get_result_type<Func, void_t<typename Func::result_type>> {
    using result_type = typename Func::result_type;
};
 
 
template <typename Func>
struct __weak_result_type_impl : maybe_get_result_type<Func> {};
 
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res(Args...)> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res(Args..., ...)> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res (*)(Args...)> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res (*)(Args..., ...)> {
    using result_type = Res;
};
 
#ifdef NEFORCE_STANDARD_17
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res(Args...) noexcept> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res(Args..., ...) noexcept> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res (*)(Args...) noexcept> {
    using result_type = Res;
};
template <typename Res, typename... Args>
struct __weak_result_type_impl<Res (*)(Args..., ...) noexcept> {
    using result_type = Res;
};
#endif
 
 
template <typename Func, bool = is_member_function_pointer<Func>::value>
struct __weak_result_type_memfun : __weak_result_type_impl<Func> {};
 
template <typename MemFunPtr>
struct __weak_result_type_memfun<MemFunPtr, true> {
    using result_type = typename mem_func_traits<MemFunPtr>::result_type;
};
 
template <typename Func, typename Class>
struct __weak_result_type_memfun<Func Class::*, false> {};

template <typename Func>
struct weak_result_type : __weak_result_type_memfun<remove_cv_t<Func>> {};
 

template <typename MemberPtr, bool IsMemFunc = is_member_function_pointer_v<MemberPtr>>
class mem_func_base : public inner::mem_func_traits<MemberPtr>::maybe_type {
    using Traits = inner::mem_func_traits<MemberPtr>; 
    using Arity = typename Traits::arity;             
    using Varargs = typename Traits::vararg;          
 
    template <typename Func, typename... BoundArgs>
    friend struct bind_check_arity;
 
    MemberPtr ptr_; 
 
public:
    using result_type = typename Traits::result_type;

    explicit constexpr mem_func_base(MemberPtr pmf) noexcept :
    ptr_(pmf) {}

    template <typename... Args>
    NEFORCE_CONSTEXPR20 auto operator()(Args&&... args) const
            noexcept(noexcept(_NEFORCE invoke(ptr_, _NEFORCE forward<Args>(args)...)))
                    -> decltype(_NEFORCE invoke(ptr_, _NEFORCE forward<Args>(args)...)) {
        return _NEFORCE invoke(ptr_, _NEFORCE forward<Args>(args)...);
    }
};

template <typename MemberObjPtr>
class mem_func_base<MemberObjPtr, false> {
    using Arity = integral_constant<size_t, 0>;
    using Varargs = false_type;
 
    template <typename Func, typename... BoundArgs>
    friend struct bind_check_arity;
 
    MemberObjPtr ptr_;
 
public:
    explicit constexpr mem_func_base(MemberObjPtr pm) noexcept :
    ptr_(pm) {}

    template <typename T>
    NEFORCE_CONSTEXPR20 auto operator()(T&& obj) const
            noexcept(noexcept(_NEFORCE invoke(ptr_, _NEFORCE forward<T>(obj))))
                    -> decltype(_NEFORCE invoke(ptr_, _NEFORCE forward<T>(obj))) {
        return _NEFORCE invoke(ptr_, _NEFORCE forward<T>(obj));
    }
};
 
template <typename MemberPointer>
struct mem_func;
 
template <typename Res, typename Class>
struct mem_func<Res Class::*> : mem_func_base<Res Class::*> {
    using mem_func_base<Res Class::*>::mem_func_base;
};
 
NEFORCE_END_INNER__
 


template <typename T>
struct is_bind_expression : false_type {};

template <typename T>
NEFORCE_INLINE17 constexpr bool is_bind_expression_v = is_bind_expression<T>::value;
 

template <uint32_t Num>
struct placeholder : uint32_constant<Num> {};

template <uint32_t Num>
NEFORCE_INLINE17 constexpr uint32_t placeholder_v = placeholder<Num>::value;
 

template <typename T>
struct is_placeholder;
 
template <uint32_t Num>
struct is_placeholder<placeholder<Num>> : true_type {};

template <typename T>
NEFORCE_INLINE17 constexpr bool is_placeholder_v = is_placeholder<T>::value;

namespace placeholders {
    NEFORCE_INLINE17 constexpr placeholder<1> p1{};   
    NEFORCE_INLINE17 constexpr placeholder<2> p2{};   
    NEFORCE_INLINE17 constexpr placeholder<3> p3{};   
    NEFORCE_INLINE17 constexpr placeholder<4> p4{};   
    NEFORCE_INLINE17 constexpr placeholder<5> p5{};   
    NEFORCE_INLINE17 constexpr placeholder<6> p6{};   
    NEFORCE_INLINE17 constexpr placeholder<7> p7{};   
    NEFORCE_INLINE17 constexpr placeholder<8> p8{};   
    NEFORCE_INLINE17 constexpr placeholder<9> p9{};   
    NEFORCE_INLINE17 constexpr placeholder<10> p10{}; 
    NEFORCE_INLINE17 constexpr placeholder<11> p11{}; 
    NEFORCE_INLINE17 constexpr placeholder<12> p12{}; 
    NEFORCE_INLINE17 constexpr placeholder<13> p13{}; 
    NEFORCE_INLINE17 constexpr placeholder<14> p14{}; 
    NEFORCE_INLINE17 constexpr placeholder<15> p15{}; 
    NEFORCE_INLINE17 constexpr placeholder<16> p16{}; 
    NEFORCE_INLINE17 constexpr placeholder<17> p17{}; 
    NEFORCE_INLINE17 constexpr placeholder<18> p18{}; 
    NEFORCE_INLINE17 constexpr placeholder<19> p19{}; 
    NEFORCE_INLINE17 constexpr placeholder<20> p20{}; 
    NEFORCE_INLINE17 constexpr placeholder<21> p21{}; 
    NEFORCE_INLINE17 constexpr placeholder<22> p22{}; 
    NEFORCE_INLINE17 constexpr placeholder<23> p23{}; 
    NEFORCE_INLINE17 constexpr placeholder<24> p24{}; 
    NEFORCE_INLINE17 constexpr placeholder<25> p25{}; 
    NEFORCE_INLINE17 constexpr placeholder<26> p26{}; 
    NEFORCE_INLINE17 constexpr placeholder<27> p27{}; 
    NEFORCE_INLINE17 constexpr placeholder<28> p28{}; 
    NEFORCE_INLINE17 constexpr placeholder<29> p29{}; 
} // namespace placeholders
 

NEFORCE_BEGIN_INNER__

template <typename Arg, bool IsBindExp = is_bind_expression_v<Arg>, bool IsPlaceholder = is_placeholder_v<Arg>>
class bind_arg_mapper;
 
template <typename T>
class bind_arg_mapper<reference_wrapper<T>, false, false> {
public:
    template <typename CVRef, typename Tuple>
    NEFORCE_CONSTEXPR20 T& operator()(CVRef& arg, Tuple&) const volatile {
        return arg.get();
    }
};
 
template <typename Arg>
class bind_arg_mapper<Arg, true, false> {
public:
    template <typename CVArg, typename... Args>
    NEFORCE_CONSTEXPR20 auto operator()(CVArg& arg, tuple<Args...>& tuple_ref) const volatile
            -> decltype(arg(declval<Args>()...)) {
        using Indexes = build_index_tuple_t<sizeof...(Args)>;
        return call(arg, tuple_ref, Indexes());
    }
 
private:
    template <typename CVArg, typename... Args, size_t... Indexes>
    NEFORCE_CONSTEXPR20 auto call(CVArg& arg, tuple<Args...>& tuple_ref, const index_tuple<Indexes...>&) const volatile
            -> decltype(arg(declval<Args>()...)) {
        return arg(_NEFORCE get<Indexes>(_NEFORCE move(tuple_ref))...);
    }
};
 
 
template <typename Arg>
class bind_arg_mapper<Arg, false, true> {
    template <size_t I, typename Tuple>
    using safe_tuple_element_t = enable_if_t<(I < tuple_size_v<Tuple>), tuple_element_t<I, Tuple>>;
 
public:
    template <typename Tuple>
    NEFORCE_CONSTEXPR20 safe_tuple_element_t<(is_placeholder_v<Arg> - 1), Tuple>&& operator()(const volatile Arg&,
                                                                                              Tuple& tuple_ref) const
            volatile {
        return _NEFORCE get<(is_placeholder<Arg>::value - 1)>(_NEFORCE move(tuple_ref));
    }
};
 
template <typename Arg>
class bind_arg_mapper<Arg, false, false> {
public:
    template <typename CVArg, typename Tuple>
    NEFORCE_CONSTEXPR20 CVArg&& operator()(CVArg&& arg, Tuple&) const volatile {
        return _NEFORCE forward<CVArg>(arg);
    }
};
 
NEFORCE_END_INNER__
 // BindTraits


template <typename Sign>
class binder;

template <typename Func, typename... BoundArgs>
class binder<Func(BoundArgs...)> : public inner::weak_result_type<Func> {
private:
    using BoundIndexes = build_index_tuple_t<sizeof...(BoundArgs)>; 
 
    Func functor_;                   
    tuple<BoundArgs...> bound_args_; 
 
private:
    template <typename BoundArg, typename CallArgs>
    struct arg_mapper_result {
        using type = decltype(inner::bind_arg_mapper<remove_cv_t<BoundArg>>()(_NEFORCE declval<BoundArg&>(),
                                                                              _NEFORCE declval<CallArgs&>()));
    };

    template <typename BoundArg, typename CallArgs>
    using arg_mapper_result_t = typename arg_mapper_result<BoundArg, CallArgs>::type;

    template <typename CallArgs>
    using result_type = invoke_result_t<Func&, arg_mapper_result_t<BoundArgs, CallArgs>...>;

    template <typename CallArgs>
    using result_type_const = invoke_result_t<const Func&, arg_mapper_result_t<const BoundArgs, CallArgs>...>;

    template <typename BoundArg, typename CallArgs>
    using arg_mapper_type = decltype(inner::bind_arg_mapper<remove_cv_t<BoundArg>>()(_NEFORCE declval<BoundArg&>(),
                                                                                     _NEFORCE declval<CallArgs&>()));

    template <typename CallArgs>
    using dependent = enable_if_t<static_cast<bool>(tuple_size_v<CallArgs> + 1), Func>;
 
private:
    template <typename Res, typename... Args, size_t... Indexes>
    NEFORCE_CONSTEXPR20 Res call(tuple<Args...>&& args, index_tuple<Indexes...> idx) {
        return _NEFORCE invoke(functor_,
                               inner::bind_arg_mapper<BoundArgs>()(_NEFORCE get<Indexes>(bound_args_), args)...);
    }

    template <typename Res, typename... Args, _NEFORCE size_t... Indexes>
    NEFORCE_CONSTEXPR20 Res call_const(tuple<Args...>&& args, index_tuple<Indexes...> idx) const {
        return _NEFORCE invoke(functor_,
                               inner::bind_arg_mapper<BoundArgs>()(_NEFORCE get<Indexes>(bound_args_), args)...);
    }
 
public:
    template <typename... Args>
    explicit NEFORCE_CONSTEXPR20 binder(Func&& func, Args&&... args) :
    functor_(_NEFORCE forward<Func>(func)),
    bound_args_(_NEFORCE forward<Args>(args)...) {}
 
    binder(const binder&) = default; 
    binder(binder&&) = default;      

    template <typename... Args>
    NEFORCE_CONSTEXPR20 auto operator()(Args&&... args) -> result_type<tuple<Args&&...>> {
        using Res = result_type<tuple<Args&&...>>;
        return binder::call<Res>(_NEFORCE forward_as_tuple(_NEFORCE forward<Args>(args)...), BoundIndexes());
    }

    template <typename... Args>
    NEFORCE_CONSTEXPR20 auto operator()(Args&&... args) const -> result_type_const<tuple<Args&&...>> {
        using Res = result_type_const<tuple<Args&&...>>;
        return binder::call_const<Res>(_NEFORCE forward_as_tuple(_NEFORCE forward<Args>(args)...), BoundIndexes());
    }
 
    template <typename... Args>
    void operator()(Args&&... args) const volatile = delete;
};
 

template <typename Res, typename Sign>
class bindrer;

template <typename Res, typename Func, typename... BoundArgs>
class bindrer<Res, Func(BoundArgs...)> {
private:
    using BoundIndexes = build_index_tuple_t<sizeof...(BoundArgs)>; 
 
    Func functor_;                   
    tuple<BoundArgs...> bound_args_; 
 
private:
    template <typename Result, typename... Args, size_t... Indexes>
    NEFORCE_CONSTEXPR20 Result call(tuple<Args...>&& args, index_tuple<Indexes...> idx) {
        return _NEFORCE invoke_r<Res>(functor_,
                                      inner::bind_arg_mapper<BoundArgs>()(_NEFORCE get<Indexes>(bound_args_), args)...);
    }

    template <typename Result, typename... Args, _NEFORCE size_t... Indexes>
    NEFORCE_CONSTEXPR20 Result call(tuple<Args...>&& args, index_tuple<Indexes...> idx) const {
        return _NEFORCE invoke_r<Res>(functor_,
                                      inner::bind_arg_mapper<BoundArgs>()(_NEFORCE get<Indexes>(bound_args_), args)...);
    }
 
public:
    using result_type = Res; 

    template <typename... Args>
    explicit NEFORCE_CONSTEXPR20 bindrer(Func&& func, Args&&... args) :
    functor_(_NEFORCE forward<Func>(func)),
    bound_args_(_NEFORCE forward<Args>(args)...) {}
 
    bindrer(const bindrer&) = default; 
    bindrer(bindrer&&) = default;      

    template <typename... Args>
    NEFORCE_CONSTEXPR20 result_type operator()(Args&&... args) {
        return bindrer::call<Res>(_NEFORCE forward_as_tuple(_NEFORCE forward<Args>(args)...), BoundIndexes());
    }

    template <typename... Args>
    NEFORCE_CONSTEXPR20 result_type operator()(Args&&... args) const {
        return bindrer::call<Res>(_NEFORCE forward_as_tuple(_NEFORCE forward<Args>(args)...), BoundIndexes());
    }
 
    template <typename... Args>
    void operator()(Args&&... args) const volatile = delete;
};
 

 
template <typename Sign>
struct is_bind_expression<binder<Sign>> : true_type {};
template <typename Res, typename Sign>
struct is_bind_expression<bindrer<Res, Sign>> : true_type {};
 
#define __NEFORCE_EXPAND_BIND_EXP(CV)                          \
    template <typename Sign>                                   \
    struct is_bind_expression<CV binder<Sign>> : true_type {}; \
    template <typename Res, typename Sign>                     \
    struct is_bind_expression<CV bindrer<Res, Sign>> : true_type {};
 
NEFORCE_MACRO_RANGES_CV(__NEFORCE_EXPAND_BIND_EXP)
#undef __NEFORCE_EXPAND_BIND_EXP
 
NEFORCE_BEGIN_INNER__

template <typename Func, typename... BoundArgs>
struct bind_check_arity {};
 
template <typename Ret, typename... Args, typename... BoundArgs>
struct bind_check_arity<Ret (*)(Args...), BoundArgs...> {
    static_assert(sizeof...(BoundArgs) == sizeof...(Args), "Wrong number of arguments for function");
};
 
template <typename Ret, typename... Args, typename... BoundArgs>
struct bind_check_arity<Ret (*)(Args..., ...), BoundArgs...> {
    static_assert(sizeof...(BoundArgs) >= sizeof...(Args), "Wrong number of arguments for function");
};
 
template <typename T, typename Class, typename... BoundArgs>
struct bind_check_arity<T Class::*, BoundArgs...> {
    using Arity = typename mem_func<T Class::*>::Arity;
    using Varargs = typename mem_func<T Class::*>::Varargs;
    static_assert(Varargs::value ? sizeof...(BoundArgs) >= Arity::value + 1 : sizeof...(BoundArgs) == Arity::value + 1,
                  "Wrong number of arguments for pointer-to-member");
};
 
NEFORCE_END_INNER__

template <bool IntLike, typename Func, typename... BoundArgs>
struct bind_helper : inner::bind_check_arity<decay_t<Func>, BoundArgs...> {
    using func_type = decay_t<Func>;                       
    using type = binder<func_type(decay_t<BoundArgs>...)>; 
};
 
template <typename Func, typename... BoundArgs>
struct bind_helper<true, Func, BoundArgs...> {};

template <bool IntLike, typename Func, typename... BoundArgs>
using bind_helper_t = typename bind_helper<IntLike, Func, BoundArgs...>::type;
 

template <typename Func, typename... BoundArgs>
NEFORCE_DEPRECATED_FOR("use lambda or bind_front instead of bind")
NEFORCE_NODISCARD
        constexpr bind_helper_t<is_integral_like_v<Func>, Func, BoundArgs...> bind(Func&& func, BoundArgs&&... args) {
    return bind_helper_t<false, Func, BoundArgs...>(_NEFORCE forward<Func>(func), _NEFORCE forward<BoundArgs>(args)...);
}
 

template <typename Res, typename Func, typename... BoundArgs>
struct bindr_helper : inner::bind_check_arity<decay_t<Func>, BoundArgs...> {
    using type = bindrer<Res, decay_t<Func>(decay_t<BoundArgs>...)>;
};

template <typename Res, typename Func, typename... BoundArgs>
using bindr_helper_t = typename bindr_helper<Res, Func, BoundArgs...>::type;
 

template <typename Res, typename Func, typename... BoundArgs>
NEFORCE_DEPRECATED_FOR("use lambda or bind_front instead of bind")
NEFORCE_NODISCARD constexpr bindr_helper_t<Res, Func, BoundArgs...> bind(Func&& func, BoundArgs&&... args) {
    return bindr_helper_t<Res, Func, BoundArgs...>(_NEFORCE forward<Func>(func), _NEFORCE forward<BoundArgs>(args)...);
}
 

template <typename Func, typename... BoundArgs>
struct binder_front {
    static_assert(is_move_constructible<Func>::value, "Func should be move constructible");
#ifdef NEFORCE_STANDARD_17
    static_assert((is_move_constructible_v<BoundArgs> && ...), "Args should be move constructible");
#endif
 
private:
    using BoundIndices = index_sequence_for<BoundArgs...>; 
 
    Func func_;                      
    tuple<BoundArgs...> bound_args_; 
 
private:
    template <typename T, size_t... Indices, typename... CallArgs>
    static constexpr decltype(auto) call(T&& bind_object, index_sequence<Indices...> idx, CallArgs&&... call_args) {
        return _NEFORCE invoke(_NEFORCE forward<T>(bind_object).func_,
                               _NEFORCE get<Indices>(_NEFORCE forward<T>(bind_object).bound_args_)...,
                               _NEFORCE forward<CallArgs>(call_args)...);
    }
 
public:
    template <typename Fn, typename... Args>
    explicit constexpr binder_front(int p, Fn&& func, Args&&... args) noexcept(
            conjunction<is_nothrow_constructible<Func, Fn>, is_nothrow_constructible<BoundArgs, Args>...>::value) :
    func_(_NEFORCE forward<Fn>(func)),
    bound_args_(_NEFORCE forward<Args>(args)...) {
        static_assert(sizeof...(Args) == sizeof...(BoundArgs), "Wrong number of arguments");
    }
 
    binder_front(const binder_front&) = default;            
    binder_front& operator=(const binder_front&) = default; 
    binder_front(binder_front&&) = default;                 
    binder_front& operator=(binder_front&&) = default;      
 
    ~binder_front() = default; 

    template <typename... CallArgs>
    constexpr invoke_result_t<Func&, BoundArgs&..., CallArgs...>
    operator()(CallArgs&&... call_args) & noexcept(is_nothrow_invocable_v<Func&, BoundArgs&..., CallArgs...>) {
        return binder_front::call(*this, BoundIndices(), _NEFORCE forward<CallArgs>(call_args)...);
    }

    template <typename... CallArgs>
    constexpr invoke_result_t<const Func&, const BoundArgs&..., CallArgs...> operator()(CallArgs&&... call_args)
            const& noexcept(is_nothrow_invocable_v<const Func&, const BoundArgs&..., CallArgs...>) {
        return binder_front::call(*this, BoundIndices(), _NEFORCE forward<CallArgs>(call_args)...);
    }

    template <typename... CallArgs>
    constexpr invoke_result_t<Func, BoundArgs..., CallArgs...>
    operator()(CallArgs&&... call_args) && noexcept(is_nothrow_invocable_v<Func, BoundArgs..., CallArgs...>) {
        return binder_front::call(_NEFORCE move(*this), BoundIndices(), _NEFORCE forward<CallArgs>(call_args)...);
    }

    template <typename... CallArgs>
    constexpr invoke_result_t<const Func, const BoundArgs..., CallArgs...> operator()(CallArgs&&... call_args)
            const&& noexcept(is_nothrow_invocable_v<const Func, const BoundArgs..., CallArgs...>) {
        return binder_front::call(_NEFORCE move(*this), BoundIndices(), _NEFORCE forward<CallArgs>(call_args)...);
    }
};

template <typename Func, typename... Args>
using binder_front_type = binder_front<decay_t<Func>, decay_t<Args>...>;

template <typename Func, typename... Args>
NEFORCE_NODISCARD constexpr binder_front_type<Func, Args...> bind_front(Func&& func, Args&&... args) noexcept(
        is_nothrow_constructible<binder_front_type<Func, Args...>, int, Func, Args...>::value) {
    return binder_front_type<Func, Args...>(0, _NEFORCE forward<Func>(func), _NEFORCE forward<Args>(args)...);
}
 // FunctionBinders
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_BIND_HPP__