#include <iostream>
#include <vector>
 
template < typename Derived, typename R, typename T >
struct cascade_call_base {
    
    typedef R result_type;
    
    typedef T param_type;
    typedef param_type const & param_ref;
    
    typedef std::vector<param_type> params_type;
    typedef params_type const & params_ref;
    
    struct param_packer {
        Derived & callee;
        params_type params;
        
        param_packer( Derived & callee, param_ref first ) 
        : callee(callee), params( 1, first )
        { }
        
        param_packer& operator,( param_ref append ) {
            params.push_back( append );
            return *this;
        }
        
        operator result_type() {
            return callee.invoke( params );
        }
    };
    
    param_packer
    operator,( param_ref first ) {
        return param_packer( static_cast<Derived&>(*this), first );
    }
};
 
struct Test : cascade_call_base<Test,int,int> {
    result_type  
    invoke( params_ref params ) {
        return params.size();
    }
} test;
 
int main() {
    
    using namespace std;
    
    cout << (test,1,2,3) << endl;
    cout << (test,4,5) << endl;
}