template <class F, class... Args>
    void fa(F f, Args&&... args) {
        [](...){}((f(std::forward<Args>(args)), 0)...);
}

template <class F, class... Args> void fa( F f, Args&&... args )
{
    []( ... ) {}( ( f( std::forward<Args>( args ) ), 0 )... );
}

fa( []( int a ) { cout << a ); }, 1, 2, 3, 4, 5 );

H_C>template <class F, class... Args>
H_C>    void fa(F f, Args&&... args) {
H_C>        [](...){}((f(std::forward<Args>(args)), 0)...);
H_C>}
H_C>

(void)std::initializer_list<int>{(f(std::forward<Args>(args)), void(), 0)...};

void devnull(...) {}

#define CALL(expr) ( (expr), void(), 0 ) // выполняет выражение, возможно, типа void, и возвращает int 0

template<class F, class... Xs>
void each(F f, Xs&&... xs)
{
  devnull( CALL(f(xs))... );
  (void) std::initializer_list<int> { CALL(f(xs))... };
  int nulls[] = { CALL(f(xs))... };

}

#define COMMA(x,y) ((x),(y))
#define CALL(expr) COMMA( COMMA((expr),void()), 0 )

int v = 0;
((void)v);

XC>Что-то эта тема (шаблоны с переменным числом аргументов) как-то вообще мимо меня прошла

template<bla,bla,bla> struct Foo; // не обязательно вариадик, а просто много-много-арный шаблон

void foo(bla,bla,bla); // то же самое - там могут быть и дефолтные параметры, и сишный эллипсис,
void foo(); // и перегрузки, и что угодно


template<class... Args> void bar(Args... args) // если параметры шаблона не указаны, они довыводятся из аргументов
{
  Foo<Args...> x; // подставили параметры шаблона - здесь типы - в параметры другого шаблона.
  foo(args...); // подставили серию аргументов
  sizeof...(Args); // число параметров шаблона
  sizeof...(args); // число аргументов функции

  int   xs[] = { f<Args>()... }; // подставили каждый элемент Args в выражение - например, в шаблон функции
  void* ys[] = { new Args()... }; // необязательно в шаблон - типы можно использовать как угодно
  int   zs[] = { f(args)... }; // подставили каждый элемент args
}

template<class... Args> struct mpl_series {};

// можно делать сопоставление глубоко

template<class> struct mpl_front;
template<class X, class... Args> struct mpl_front< mpl_series<X,Args...> > { typedef X type; };

// а можно и непосредственно

template<class... Args> struct mpl_sizeof;
template<> struct mpl_sizeof<> {
  static int const value = 1;
};
template<class X, class... Rest> struct mpl_sizeof<X,Rest...> {
  static int const value = 1 + mpl_sizeof<Rest...>::value;
};

// единственно, склеивать две последовательности напрямую не выйдет, хотя бы одна должна быть упакована

template<class Series, class...> struct mpl_append;
template<class... Xs, class... Ys> struct mpl_append< mpl_series<Xs...>, Ys... >
 { typedef mpl_series<Xs...,Ys...> type; };

template<class Series1, class Series2> struct mpl_concat;
template<class... Xs, class... Ys> struct mpl_concat< mpl_series<Xs...>, mpl_series<Ys...> >
 { typedef mpl_series<Xs...,Ys...> type; };

// и, с хвостом серии нельзя напрямую сопоставляться, хвост можно только порождать

template<class Series> struct mpl_rotate;
template<class X, class...Ys> struct mpl_rotate< mpl_series<X,Ys...> >
 { typedef mpl_series<Ys...,X> };