Is it possible to allow variadic template expansion? about dbg-macro HOT 8 OPEN

#include <dbg.h>

template <typename... T>
int sum(T&&... args) {
  return (args + ...);
}

template <typename... T>
int calc(T&&... args) {
  // Some other logic here in real world...

  // This will return 3 instead of 6 :O
  // return sum(dbg::identity(args...));

  return sum(args...);
}

int main() {
  dbg(calc(1, 2, 3));
  return 0;
}

template <typename... ARGS>
void proxy(ARGS&&... args) {
  /* dbg::DebugOutput(__FILE__, __LINE__, __func__)
    .print({DBG_MAP(DBG_STRINGIFY, args...)},
           {(... + (" " + dbg::type_name<decltype(args)>()))},
           args...); */
  std::cout << (... + (" " + dbg::type_name<decltype(args)>())) << std::endl;
}

int main(void) {
  proxy(1, 'v');
  // test('1');
  return 0;
}

#define DBG_TYPE_NAME(x) dbg::type_name<decltype(x)>()

#define DBG_TYPE_NAME(x) (... + (" " + dbg::type_name<decltype(args)>()))

template <typename... ARGS>
void test(const ARGS&... args) {
  dbg("Args: ", args...);
}

int main(void)
{
  test(1);
  test('1');
  return 0;
}

#include <typeinfo>

template <typename... T>
void test(T&& ...args) {
  /* std::cout << typeid(args...).name() << std::endl; */
  typeid(args...).name();
  // typeid(1).name();
};

int main(void)
{
  test('v', 1);
  return 0;
}

template <int N, typename... Ts>
using NthTypeOf = typename std::tuple_element<N, std::tuple<Ts...>>::type;

template <typename... ARGS>
void f(ARGS&&... args) {
  dbg::DebugOutput(__FILE__, __LINE__, __func__)
      .print({DBG_MAP(DBG_STRINGIFY, args...)},
             {dbg::type_name<NthTypeOf<0, ARGS...>>() + ", " +
              dbg::type_name<NthTypeOf<1, ARGS...>>()},
             args...);  // Here should be logic, which would evaluate args as a
                        // single variable
}

template <typename... ARGS>
void proxy(ARGS&&... args) {
  dbg::DebugOutput(__FILE__, __LINE__, __func__)
      .print({DBG_MAP(DBG_STRINGIFY, args...)},
             {dbg::type_name<NthTypeOf<0, ARGS...>>() + ", " +
              dbg::type_name<NthTypeOf<1, ARGS...>>()},
             args...);  // Here should be logic, which would evaluate args as a
                        // single variable
  f(args...);
}

int main(void) {
  proxy(1, 'v');
  // test('1');
  return 0;
}