I gave a glance to the papers about variadic templates and I didn't see examples using a construct such as f(args)... where args is a function parameter pack; so I guess that the following code it's illegal: template< typename T > T max( T x ) { return x; } template< typename T, typename... Args > // where are_same<T, Args...> T max( T x, T y, Args... args ) { return std::max( x, max( y, args... ) ); } // #1 template< typename T, typename... Args > // where are_same<T, Args...> T max_abs( T x, T y, Args... args ) { // this is the (probably) illegal construct: return max( abs(x), abs(y), abs(args)... ); // I'd like that "abs(args)..." expands to "abs(arg1), ... ,abs(argN)" } What's the rationale behind such a design choice ? I admit that a simple workaround exists: // #2 template< typename T > T max_abs( T x ) { return abs(x); } template< typename T, typename... Args > // where are_same<T, Args...> T max_abs( T x, T y, Args... args ) { return std::max(abs(x), max_abs(y, args...) ); } anyway version #1 is more straightforward, and maybe it's possible to make up examples more complex than mine. Another question: given the following functions: // #1 template< typename T > void f(T ) {} // #2 template< typename T, typename... Args > void f(T, Args... ) {} the function call f(1,2) is it ambiguous ? if it isn't, which is the function called ? #1 because it's more specialized ? (only a guess) Kind Regards, Marco -- Using Opera's revolutionary e-mail client: http://www.opera.com/mail/