#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/bind/arg.hpp>
#include <boost/static_assert.hpp>
#include <iostream>

void fn_1(int){}
void fn_2(int,int){}
void fn_3(int,int,int){}
void fn_0(){}

namespace _bi=boost::_bi;

template<class BindTType>
struct nargs;

template<typename T> struct argpos;

template<int pos>
struct
argpos<boost::arg<pos> >
{
    enum{value=pos};
};

template<typename T>
struct
argpos<_bi::value<T> >
{
    enum{value=0};
};

template<class R, class F> 
struct nargs<_bi::bind_t<R,F,_bi::list0> >{enum {value=0};};

template<class R, class F,typename A1> 
struct nargs<
    _bi::bind_t<
    R,
    F,
    _bi::list1<A1> 
> >
{enum {value=argpos<A1>::value};};

template<int lhs, int rhs>
struct max
{    
    enum{value=lhs > rhs?lhs:rhs};
};

template<class R, class F,typename A1, typename A2>
struct nargs<
    _bi::bind_t<
    R,
    F,
    _bi::list2<A1,A2 >
> >
{
    enum
    {
	argpos1=argpos<A1>::value,
	argpos2=argpos<A2>::value,
	value=max<argpos1,argpos2>::value
    };
};

template<typename R, class F, typename A1, typename A2,typename A3>
struct nargs<
    _bi::bind_t<
    R,
    F,
    _bi::list3<A1,A2,A3>
> >
{
    enum
    {
	argpos1=argpos<A1>::value,
	argpos2=argpos<A2>::value,
	argpos3=argpos<A3>::value,
	value=max<argpos1,max<argpos2,argpos3>::value>::value
    };
};

template<int value,class BindExpr>
void bind_nargs(BindExpr)
{
    BOOST_STATIC_ASSERT(nargs<BindExpr>::value==value);
}

int main()
{
    bind_nargs<0>(boost::bind(&fn_0));
    int a=1,b=3;
    // when all args are supplied, should be 0
    bind_nargs<0>(boost::bind(&fn_2,a,b)); 
    bind_nargs<0>(boost::bind(&fn_0));

    bind_nargs<4>(boost::bind(&fn_1,_4));
    bind_nargs<9>(boost::bind(&fn_2,_8,_9));
    bind_nargs<2>(boost::bind(&fn_2,_1,_2));

    bind_nargs<2>(boost::bind(&fn_2,_1,_2));
    bind_nargs<1>(boost::bind(&fn_3,_1,_1,_1));
}