#include <iostream>
#include <functional>
#include <string>

namespace fx {
    template<int I> struct placeholder{};
}

namespace std{
    template<int I>
    struct is_placeholder< ::fx::placeholder<I>> : std::integral_constant<int, I>{};
}

namespace fx {
    template <size_t... Is>
    struct indices {};

    template <size_t N, std::size_t... Is>
    struct build_indices : build_indices<N-1, N-1, Is...> {};

    template <size_t... Is>
    struct build_indices<0, Is...> : indices<Is...> {};

    template<std::size_t... Is, class F, class... Args>
    auto easy_bind(indices<Is...>, F const& f, Args&&... args)
    -> decltype(std::bind(f, std::forward<Args>(args)..., placeholder<Is + 1>{}...))
    {
        return std::bind(f, std::forward<Args>(args)..., placeholder<Is + 1>{}...);
    }
    
    template<class R, class... FArgs, class... Args>
    auto easy_bind(std::function<R(FArgs...)> f, Args&&... args)
    -> decltype(fx::easy_bind(build_indices<sizeof...(FArgs) - sizeof...(Args)>{}, f, std::forward<Args>(args)...)) {
    return fx::easy_bind(build_indices<sizeof...(FArgs) - sizeof...(Args)>{}, f, std::forward<Args>(args)...);
    }
    
    template<class R, class... FArgs, class... Args>
    auto easy_bind(R (*f)(FArgs...), Args&&... args)
    -> decltype(fx::easy_bind(build_indices<sizeof...(FArgs) - sizeof...(Args)>{}, f, std::forward<Args>(args)...)) {
    	return fx::easy_bind(build_indices<sizeof...(FArgs) - sizeof...(Args)>{}, f, std::forward<Args>(args)...);
    }
    
    template <typename R, typename T, typename... FArgs, typename... Args>
	auto easy_bind(R (T::*mf)(FArgs...), Args&&... args)
	-> decltype(fx::easy_bind(std::function<R(T*,FArgs...)>(mf), args...))
	{
	    return fx::easy_bind(std::function<R(T*,FArgs...)>(mf), args...);
	}

}

//Test Case:
struct SomeStruct {
    void function(int x, float y, std::string str) {
        std::cout << x << " " << y << " " << str << std::endl;    
    }
};


int main() {
	auto f = fx::easy_bind(&SomeStruct::function, new SomeStruct);
	f(5,2.5,"test");
    
    return 0;
}

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