#include <boost/function_types/function_type_arity.hpp>
#include <boost/function_types/function_type_result.hpp>
#include <boost/function_types/is_function_type.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/typeof/typeof.hpp>
#include <iostream>

    template<
        typename Function, 
        size_t N = boost::function_type_arity<Function>::value 
    > 
    struct function_feeder;

    template<typename F>
    struct function_feeder<F,0>{
        template< 
            class Tuple
        >
        static
        typename boost::function_type_result<
            F
        >::type
        feed(F f, Tuple& )
        {
            return f();
        }
    };

    template<typename F>
    struct function_feeder<F,1>{
        template< 
            class Tuple
        >
        static
        typename boost::function_type_result<
            F
        >::type
        feed(F f, Tuple& t)
        {
            return f(boost::get<0>(t));
        }
    };
    template<typename F>
    struct function_feeder<F,2>{
        template<
            class Tuple
        >
        static
        typename boost::function_type_result<
            F
        >::type
        feed(F f, Tuple& t)
        {
            return f(boost::get<0>(t),boost::get<1>(t));
        }
    };
   
    template<
        class Function, 
        class Tuple
    >
   typename boost::enable_if<
        ::boost::is_function_type<boost::function_pointer,Function>,
        typename boost::function_type_result<Function>::type
    >::type
    feed_function(Function f, Tuple& t)
    {
        return function_feeder<Function>::feed(f,t);
    }


   // some simple function s to test 
bool is_less (double const & lhs , double const & rhs)
{
    return lhs < rhs;   
}
bool is_greater_than (double const & lhs , double const& rhs)
{
    return lhs > rhs;   
}
template< int N>
double abs_diff(double const & in)
{
    double t = in - N;
    return t >= 0 ? t : -t;
} 
void hello_f()
{
    std::cout << "hello\n";
}
int main()
{
    // create the wrapper struct to call the converted function
  
    BOOST_AUTO(args0,(boost::make_tuple(1.,2)));
    BOOST_AUTO(args1,(boost::make_tuple(20.)));
    std::cout << feed_function(is_less,args0)<< '\n';
    std::cout << feed_function(is_less,args0)<< '\n';
    std::cout << feed_function(abs_diff<200>,args1)<< '\n';
    feed_function(hello_f, boost::make_tuple());
    // any tuple of greter arity allowed
    feed_function(hello_f,args0);
}